librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
 364                         }
 365                         ndr->flags = _flags_save_string;
 366                 }
 367                 {
 368                         uint32_t _flags_save_string = ndr->flags;
 369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 370                         if (r->servername) {
 371                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
 372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 373                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
 374                         }
 375                         ndr->flags = _flags_save_string;
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 382 {
 383         uint32_t _ptr_printername;
 384         TALLOC_CTX *_mem_save_printername_0;
 385         uint32_t _ptr_servername;
 386         TALLOC_CTX *_mem_save_servername_0;
 387         if (ndr_flags & NDR_SCALARS) {
 388                 NDR_CHECK(ndr_pull_align(ndr, 5));
 389                 {
 390                         uint32_t _flags_save_string = ndr->flags;
 391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 393                         if (_ptr_printername) {
 394                                 NDR_PULL_ALLOC(ndr, r->printername);
 395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 396                         } else {
 397                                 r->printername = NULL;
 398                         }
 399                         ndr->flags = _flags_save_string;
 400                 }
 401                 {
 402                         uint32_t _flags_save_string = ndr->flags;
 403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 405                         if (_ptr_servername) {
 406                                 NDR_PULL_ALLOC(ndr, r->servername);
 407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 408                         } else {
 409                                 r->servername = NULL;
 410                         }
 411                         ndr->flags = _flags_save_string;
 412                 }
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 416                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 426                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 431                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 432                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 435                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 436                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 440                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 441         }
 442         if (ndr_flags & NDR_BUFFERS) {
 443                 {
 444                         uint32_t _flags_save_string = ndr->flags;
 445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 446                         if (r->printername) {
 447                                 uint32_t _relative_save_offset;
 448                                 _relative_save_offset = ndr->offset;
 449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 450                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 451                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 454                                 if (ndr->offset > ndr->relative_highest_offset) {
 455                                         ndr->relative_highest_offset = ndr->offset;
 456                                 }
 457                                 ndr->offset = _relative_save_offset;
 458                         }
 459                         ndr->flags = _flags_save_string;
 460                 }
 461                 {
 462                         uint32_t _flags_save_string = ndr->flags;
 463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 464                         if (r->servername) {
 465                                 uint32_t _relative_save_offset;
 466                                 _relative_save_offset = ndr->offset;
 467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 468                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 469                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 472                                 if (ndr->offset > ndr->relative_highest_offset) {
 473                                         ndr->relative_highest_offset = ndr->offset;
 474                                 }
 475                                 ndr->offset = _relative_save_offset;
 476                         }
 477                         ndr->flags = _flags_save_string;
 478                 }
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 484 {
 485         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 486         ndr->depth++;
 487         ndr_print_ptr(ndr, "printername", r->printername);
 488         ndr->depth++;
 489         if (r->printername) {
 490                 ndr_print_string(ndr, "printername", r->printername);
 491         }
 492         ndr->depth--;
 493         ndr_print_ptr(ndr, "servername", r->servername);
 494         ndr->depth++;
 495         if (r->servername) {
 496                 ndr_print_string(ndr, "servername", r->servername);
 497         }
 498         ndr->depth--;
 499         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 500         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 501         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 502         ndr_print_spoolss_Time(ndr, "time", &r->time);
 503         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 504         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 505         ndr_print_uint32(ndr, "version", r->version);
 506         ndr_print_uint32(ndr, "free_build", r->free_build);
 507         ndr_print_uint32(ndr, "spooling", r->spooling);
 508         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 509         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 510         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 511         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 512         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 513         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 514         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 515         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 516         ndr_print_uint32(ndr, "change_id", r->change_id);
 517         ndr_print_WERROR(ndr, "last_error", r->last_error);
 518         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 519         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 520         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 521         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 522         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 523         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 524         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 525         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 526         ndr->depth--;
 527 }
 528
 529 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 530 {
 531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 532 }
 533
 534 static enum ndr_err_code ndr_push_spoolss_DM_Signature(struct ndr_push *ndr, int ndr_flags, enum spoolss_DM_Signature r)
 535 {
 536         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 537         return NDR_ERR_SUCCESS;
 538 }
 539
 540 static enum ndr_err_code ndr_pull_spoolss_DM_Signature(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DM_Signature *r)
 541 {
 542         uint32_t v;
 543         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 544         *r = v;
 545         return NDR_ERR_SUCCESS;
 546 }
 547
 548 _PUBLIC_ void ndr_print_spoolss_DM_Signature(struct ndr_print *ndr, const char *name, enum spoolss_DM_Signature r)
 549 {
 550         const char *val = NULL;
 551
 552         switch (r) {
 553                 case SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA: val = "SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA"; break;
 554                 case SPOOLSS_DM_SIGNATURE_JTEXP: val = "SPOOLSS_DM_SIGNATURE_JTEXP"; break;
 555                 case SPOOLSS_DM_SIGNATURE_PSEXTRA: val = "SPOOLSS_DM_SIGNATURE_PSEXTRA"; break;
 556         }
 557         ndr_print_enum(ndr, name, "ENUM", val, r);
 558 }
 559
 560 static enum ndr_err_code ndr_push_spoolss_DM_Layout(struct ndr_push *ndr, int ndr_flags, enum spoolss_DM_Layout r)
 561 {
 562         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 static enum ndr_err_code ndr_pull_spoolss_DM_Layout(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DM_Layout *r)
 567 {
 568         uint32_t v;
 569         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 570         *r = v;
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 _PUBLIC_ void ndr_print_spoolss_DM_Layout(struct ndr_print *ndr, const char *name, enum spoolss_DM_Layout r)
 575 {
 576         const char *val = NULL;
 577
 578         switch (r) {
 579                 case SPOOLSS_DM_LAYOUT_NUP_DISABLED: val = "SPOOLSS_DM_LAYOUT_NUP_DISABLED"; break;
 580                 case SPOOLSS_DM_LAYOUT_NUP_2: val = "SPOOLSS_DM_LAYOUT_NUP_2"; break;
 581                 case SPOOLSS_DM_LAYOUT_NUP_4: val = "SPOOLSS_DM_LAYOUT_NUP_4"; break;
 582                 case SPOOLSS_DM_LAYOUT_NUP_6: val = "SPOOLSS_DM_LAYOUT_NUP_6"; break;
 583                 case SPOOLSS_DM_LAYOUT_NUP_9: val = "SPOOLSS_DM_LAYOUT_NUP_9"; break;
 584                 case SPOOLSS_DM_LAYOUT_NUP_16: val = "SPOOLSS_DM_LAYOUT_NUP_16"; break;
 585                 case SPOOLSS_DM_LAYOUT_BOOKLET: val = "SPOOLSS_DM_LAYOUT_BOOKLET"; break;
 586         }
 587         ndr_print_enum(ndr, name, "ENUM", val, r);
 588 }
 589
 590 static enum ndr_err_code ndr_push_spoolss_DM_NupDirection(struct ndr_push *ndr, int ndr_flags, enum spoolss_DM_NupDirection r)
 591 {
 592         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 593         return NDR_ERR_SUCCESS;
 594 }
 595
 596 static enum ndr_err_code ndr_pull_spoolss_DM_NupDirection(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DM_NupDirection *r)
 597 {
 598         uint32_t v;
 599         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 600         *r = v;
 601         return NDR_ERR_SUCCESS;
 602 }
 603
 604 _PUBLIC_ void ndr_print_spoolss_DM_NupDirection(struct ndr_print *ndr, const char *name, enum spoolss_DM_NupDirection r)
 605 {
 606         const char *val = NULL;
 607
 608         switch (r) {
 609                 case SPOOLSS_DM_NUP_DIRECTION_L2R_T2B: val = "SPOOLSS_DM_NUP_DIRECTION_L2R_T2B"; break;
 610                 case SPOOLSS_DM_NUP_DIRECTION_T2B_L2R: val = "SPOOLSS_DM_NUP_DIRECTION_T2B_L2R"; break;
 611                 case SPOOLSS_DM_NUP_DIRECTION_R2L_T2B: val = "SPOOLSS_DM_NUP_DIRECTION_R2L_T2B"; break;
 612                 case SPOOLSS_DM_NUP_DIRECTION_T2B_R2L: val = "SPOOLSS_DM_NUP_DIRECTION_T2B_R2L"; break;
 613         }
 614         ndr_print_enum(ndr, name, "ENUM", val, r);
 615 }
 616
 617 static enum ndr_err_code ndr_push_spoolss_DM_NupBorderFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_DM_NupBorderFlags r)
 618 {
 619         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 620         return NDR_ERR_SUCCESS;
 621 }
 622
 623 static enum ndr_err_code ndr_pull_spoolss_DM_NupBorderFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DM_NupBorderFlags *r)
 624 {
 625         uint32_t v;
 626         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 627         *r = v;
 628         return NDR_ERR_SUCCESS;
 629 }
 630
 631 _PUBLIC_ void ndr_print_spoolss_DM_NupBorderFlags(struct ndr_print *ndr, const char *name, enum spoolss_DM_NupBorderFlags r)
 632 {
 633         const char *val = NULL;
 634
 635         switch (r) {
 636                 case SPOOLSS_DM_NUP_BORDER_PRINT: val = "SPOOLSS_DM_NUP_BORDER_PRINT"; break;
 637                 case SPOOLSS_DM_NUP_BORDER_NONE: val = "SPOOLSS_DM_NUP_BORDER_NONE"; break;
 638         }
 639         ndr_print_enum(ndr, name, "ENUM", val, r);
 640 }
 641
 642 static enum ndr_err_code ndr_push_spoolss_DM_BookletFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_DM_BookletFlags r)
 643 {
 644         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 645         return NDR_ERR_SUCCESS;
 646 }
 647
 648 static enum ndr_err_code ndr_pull_spoolss_DM_BookletFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DM_BookletFlags *r)
 649 {
 650         uint32_t v;
 651         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 652         *r = v;
 653         return NDR_ERR_SUCCESS;
 654 }
 655
 656 _PUBLIC_ void ndr_print_spoolss_DM_BookletFlags(struct ndr_print *ndr, const char *name, enum spoolss_DM_BookletFlags r)
 657 {
 658         const char *val = NULL;
 659
 660         switch (r) {
 661                 case SPOOLSS_DM_BOOKLET_LEFT_FLIP: val = "SPOOLSS_DM_BOOKLET_LEFT_FLIP"; break;
 662                 case SPOOLSS_DM_BOOKLET_RIGHT_FLIP: val = "SPOOLSS_DM_BOOKLET_RIGHT_FLIP"; break;
 663         }
 664         ndr_print_enum(ndr, name, "ENUM", val, r);
 665 }
 666
 667 static enum ndr_err_code ndr_push_spoolss_DMUNI_Quality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DMUNI_Quality r)
 668 {
 669         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 670         return NDR_ERR_SUCCESS;
 671 }
 672
 673 static enum ndr_err_code ndr_pull_spoolss_DMUNI_Quality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DMUNI_Quality *r)
 674 {
 675         uint32_t v;
 676         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 677         *r = v;
 678         return NDR_ERR_SUCCESS;
 679 }
 680
 681 _PUBLIC_ void ndr_print_spoolss_DMUNI_Quality(struct ndr_print *ndr, const char *name, enum spoolss_DMUNI_Quality r)
 682 {
 683         const char *val = NULL;
 684
 685         switch (r) {
 686                 case SPOOLSS_DM_UNI_QUALITY_BEST: val = "SPOOLSS_DM_UNI_QUALITY_BEST"; break;
 687                 case SPOOLSS_DM_UNI_QUALITY_MEDIUM: val = "SPOOLSS_DM_UNI_QUALITY_MEDIUM"; break;
 688                 case SPOOLSS_DM_UNI_QUALITY_DRAFT: val = "SPOOLSS_DM_UNI_QUALITY_DRAFT"; break;
 689         }
 690         ndr_print_enum(ndr, name, "ENUM", val, r);
 691 }
 692
 693 static enum ndr_err_code ndr_push_spoolss_DMUNI_Flags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 694 {
 695         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 696         return NDR_ERR_SUCCESS;
 697 }
 698
 699 static enum ndr_err_code ndr_pull_spoolss_DMUNI_Flags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 700 {
 701         uint32_t v;
 702         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 703         *r = v;
 704         return NDR_ERR_SUCCESS;
 705 }
 706
 707 _PUBLIC_ void ndr_print_spoolss_DMUNI_Flags(struct ndr_print *ndr, const char *name, uint32_t r)
 708 {
 709         ndr_print_uint32(ndr, name, r);
 710         ndr->depth++;
 711         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_DM_UNI_FLAGS_PRINT_TEXT_AS_GRAPHICS", SPOOLSS_DM_UNI_FLAGS_PRINT_TEXT_AS_GRAPHICS, r);
 712         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_DM_UNI_FLAGS_AVOID_EMFSPOOL", SPOOLSS_DM_UNI_FLAGS_AVOID_EMFSPOOL, r);
 713         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_DM_UNI_FLAGS_CUSTOM_HALFTONING", SPOOLSS_DM_UNI_FLAGS_CUSTOM_HALFTONING, r);
 714         ndr->depth--;
 715 }
 716
 717 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_UNIDRVEXTRA(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UNIDRVEXTRA *r)
 718 {
 719         uint32_t cntr_wReserved_0;
 720         uint32_t cntr_aOptions_0;
 721         if (ndr_flags & NDR_SCALARS) {
 722                 NDR_CHECK(ndr_push_align(ndr, 4));
 723                 NDR_CHECK(ndr_push_spoolss_DM_Signature(ndr, NDR_SCALARS, SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA));
 724                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0x0022));
 725                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wCoreJTExpSize));
 726                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, ndr_size_spoolss_UNIDRVEXTRA(r, ndr->iconv_convenience, ndr->flags) + r->wCoreJTExpSize));
 727                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wOEMExtra));
 728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwChecksum32));
 729                 NDR_CHECK(ndr_push_spoolss_DMUNI_Flags(ndr, NDR_SCALARS, r->dwFlags));
 730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bReversePrint));
 731                 NDR_CHECK(ndr_push_spoolss_DM_Layout(ndr, NDR_SCALARS, r->iLayout));
 732                 NDR_CHECK(ndr_push_spoolss_DMUNI_Quality(ndr, NDR_SCALARS, r->iQuality));
 733                 for (cntr_wReserved_0 = 0; cntr_wReserved_0 < 6; cntr_wReserved_0++) {
 734                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->wReserved[cntr_wReserved_0]));
 735                 }
 736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dwOptions));
 737                 for (cntr_aOptions_0 = 0; cntr_aOptions_0 < 128; cntr_aOptions_0++) {
 738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->aOptions[cntr_aOptions_0]));
 739                 }
 740                 NDR_CHECK(ndr_push_spoolss_DM_NupDirection(ndr, NDR_SCALARS, r->dwNupDirection));
 741                 NDR_CHECK(ndr_push_spoolss_DM_NupBorderFlags(ndr, NDR_SCALARS, r->dwNupBorderFlags));
 742                 NDR_CHECK(ndr_push_spoolss_DM_BookletFlags(ndr, NDR_SCALARS, r->dwBookletFlags));
 743                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 744         }
 745         if (ndr_flags & NDR_BUFFERS) {
 746         }
 747         return NDR_ERR_SUCCESS;
 748 }
 749
 750 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_UNIDRVEXTRA(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UNIDRVEXTRA *r)
 751 {
 752         uint32_t cntr_wReserved_0;
 753         uint32_t cntr_aOptions_0;
 754         if (ndr_flags & NDR_SCALARS) {
 755                 NDR_CHECK(ndr_pull_align(ndr, 4));
 756                 NDR_CHECK(ndr_pull_spoolss_DM_Signature(ndr, NDR_SCALARS, &r->dwSignature));
 757                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wVer));
 758                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wCoreJTExpSize));
 759                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wCoreFullSize));
 760                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wOEMExtra));
 761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwChecksum32));
 762                 NDR_CHECK(ndr_pull_spoolss_DMUNI_Flags(ndr, NDR_SCALARS, &r->dwFlags));
 763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bReversePrint));
 764                 NDR_CHECK(ndr_pull_spoolss_DM_Layout(ndr, NDR_SCALARS, &r->iLayout));
 765                 NDR_CHECK(ndr_pull_spoolss_DMUNI_Quality(ndr, NDR_SCALARS, &r->iQuality));
 766                 for (cntr_wReserved_0 = 0; cntr_wReserved_0 < 6; cntr_wReserved_0++) {
 767                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->wReserved[cntr_wReserved_0]));
 768                 }
 769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dwOptions));
 770                 for (cntr_aOptions_0 = 0; cntr_aOptions_0 < 128; cntr_aOptions_0++) {
 771                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->aOptions[cntr_aOptions_0]));
 772                 }
 773                 NDR_CHECK(ndr_pull_spoolss_DM_NupDirection(ndr, NDR_SCALARS, &r->dwNupDirection));
 774                 NDR_CHECK(ndr_pull_spoolss_DM_NupBorderFlags(ndr, NDR_SCALARS, &r->dwNupBorderFlags));
 775                 NDR_CHECK(ndr_pull_spoolss_DM_BookletFlags(ndr, NDR_SCALARS, &r->dwBookletFlags));
 776                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 777         }
 778         if (ndr_flags & NDR_BUFFERS) {
 779         }
 780         return NDR_ERR_SUCCESS;
 781 }
 782
 783 _PUBLIC_ void ndr_print_spoolss_UNIDRVEXTRA(struct ndr_print *ndr, const char *name, const struct spoolss_UNIDRVEXTRA *r)
 784 {
 785         uint32_t cntr_wReserved_0;
 786         uint32_t cntr_aOptions_0;
 787         ndr_print_struct(ndr, name, "spoolss_UNIDRVEXTRA");
 788         ndr->depth++;
 789         ndr_print_spoolss_DM_Signature(ndr, "dwSignature", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?SPOOLSS_DM_SIGNATURE_UNIDRVEXTRA:r->dwSignature);
 790         ndr_print_uint16(ndr, "wVer", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x0022:r->wVer);
 791         ndr_print_uint16(ndr, "wCoreJTExpSize", r->wCoreJTExpSize);
 792         ndr_print_uint16(ndr, "wCoreFullSize", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_UNIDRVEXTRA(r, ndr->iconv_convenience, ndr->flags) + r->wCoreJTExpSize:r->wCoreFullSize);
 793         ndr_print_uint16(ndr, "wOEMExtra", r->wOEMExtra);
 794         ndr_print_uint32(ndr, "dwChecksum32", r->dwChecksum32);
 795         ndr_print_spoolss_DMUNI_Flags(ndr, "dwFlags", r->dwFlags);
 796         ndr_print_uint32(ndr, "bReversePrint", r->bReversePrint);
 797         ndr_print_spoolss_DM_Layout(ndr, "iLayout", r->iLayout);
 798         ndr_print_spoolss_DMUNI_Quality(ndr, "iQuality", r->iQuality);
 799         ndr->print(ndr, "%s: ARRAY(%d)", "wReserved", (int)6);
 800         ndr->depth++;
 801         for (cntr_wReserved_0=0;cntr_wReserved_0<6;cntr_wReserved_0++) {
 802                 char *idx_0=NULL;
 803                 if (asprintf(&idx_0, "[%d]", cntr_wReserved_0) != -1) {
 804                         ndr_print_uint16(ndr, "wReserved", r->wReserved[cntr_wReserved_0]);
 805                         free(idx_0);
 806                 }
 807         }
 808         ndr->depth--;
 809         ndr_print_uint32(ndr, "dwOptions", r->dwOptions);
 810         ndr->print(ndr, "%s: ARRAY(%d)", "aOptions", (int)128);
 811         ndr->depth++;
 812         for (cntr_aOptions_0=0;cntr_aOptions_0<128;cntr_aOptions_0++) {
 813                 char *idx_0=NULL;
 814                 if (asprintf(&idx_0, "[%d]", cntr_aOptions_0) != -1) {
 815                         ndr_print_uint32(ndr, "aOptions", r->aOptions[cntr_aOptions_0]);
 816                         free(idx_0);
 817                 }
 818         }
 819         ndr->depth--;
 820         ndr_print_spoolss_DM_NupDirection(ndr, "dwNupDirection", r->dwNupDirection);
 821         ndr_print_spoolss_DM_NupBorderFlags(ndr, "dwNupBorderFlags", r->dwNupBorderFlags);
 822         ndr_print_spoolss_DM_BookletFlags(ndr, "dwBookletFlags", r->dwBookletFlags);
 823         ndr->depth--;
 824 }
 825
 826 _PUBLIC_ size_t ndr_size_spoolss_UNIDRVEXTRA(const struct spoolss_UNIDRVEXTRA *r, struct smb_iconv_convenience *ic, int flags)
 827 {
 828         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_UNIDRVEXTRA, ic);
 829 }
 830
 831 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 832 {
 833         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 834         return NDR_ERR_SUCCESS;
 835 }
 836
 837 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 838 {
 839         uint32_t v;
 840         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 841         *r = v;
 842         return NDR_ERR_SUCCESS;
 843 }
 844
 845 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 846 {
 847         ndr_print_uint32(ndr, name, r);
 848         ndr->depth++;
 849         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 850         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 851         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 852         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 853         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 854         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 855         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 856         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 857         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 858         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 859         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 860         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 861         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 862         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 863         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 864         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 865         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 866         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 877         ndr->depth--;
 878 }
 879
 880 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 881 {
 882         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 887 {
 888         uint16_t v;
 889         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 890         *r = v;
 891         return NDR_ERR_SUCCESS;
 892 }
 893
 894 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 895 {
 896         const char *val = NULL;
 897
 898         switch (r) {
 899                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 900                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 901                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 902         }
 903         ndr_print_enum(ndr, name, "ENUM", val, r);
 904 }
 905
 906 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 907 {
 908         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 909         return NDR_ERR_SUCCESS;
 910 }
 911
 912 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 913 {
 914         uint16_t v;
 915         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 916         *r = v;
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 921 {
 922         const char *val = NULL;
 923
 924         switch (r) {
 925                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 926                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 927         }
 928         ndr_print_enum(ndr, name, "ENUM", val, r);
 929 }
 930
 931 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 932 {
 933         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 934         return NDR_ERR_SUCCESS;
 935 }
 936
 937 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 938 {
 939         uint16_t v;
 940         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 941         *r = v;
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 946 {
 947         const char *val = NULL;
 948
 949         switch (r) {
 950                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 951                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 952                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 953                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 954                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 955                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 956                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 957                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 958                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 959                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 960                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 961                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 962                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 963                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 964                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 965                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 966                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 967                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 968                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 969                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 970                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 971                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 972                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 973                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 974                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 975                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 976                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 977                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 978                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 979                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 980                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 981                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 982                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 983                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 984                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 985                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 986                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 987                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 988                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 989                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 990                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 991                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 992                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 993                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 994                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 995                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 996                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 997                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 998                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 999                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
1000                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
1001                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
1002                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
1003                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
1004                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
1005                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
1006                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
1007                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
1008                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
1009                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
1010                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
1011                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
1012                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
1013                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
1014                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
1015                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
1016                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
1017                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
1018                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
1019                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
1020                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
1021                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
1022                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
1023                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
1024                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
1025                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
1026                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
1027                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
1028                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
1029                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
1030                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
1031                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
1032                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
1033                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
1034                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
1035                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
1036                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
1037                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
1038                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
1039                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
1040                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
1041         }
1042         ndr_print_enum(ndr, name, "ENUM", val, r);
1043 }
1044
1045 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
1046 {
1047         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1048         return NDR_ERR_SUCCESS;
1049 }
1050
1051 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
1052 {
1053         uint16_t v;
1054         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1055         *r = v;
1056         return NDR_ERR_SUCCESS;
1057 }
1058
1059 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
1060 {
1061         const char *val = NULL;
1062
1063         switch (r) {
1064                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
1065                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
1066                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
1067                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
1068                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
1069                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
1070                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
1071                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
1072                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
1073                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
1074                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
1075                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
1076                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
1077         }
1078         ndr_print_enum(ndr, name, "ENUM", val, r);
1079 }
1080
1081 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
1082 {
1083         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1084         return NDR_ERR_SUCCESS;
1085 }
1086
1087 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
1088 {
1089         uint16_t v;
1090         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1091         *r = v;
1092         return NDR_ERR_SUCCESS;
1093 }
1094
1095 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
1096 {
1097         const char *val = NULL;
1098
1099         switch (r) {
1100                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
1101                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
1102                 case DMRES_LOW: val = "DMRES_LOW"; break;
1103                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
1104         }
1105         ndr_print_enum(ndr, name, "ENUM", val, r);
1106 }
1107
1108 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
1109 {
1110         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1111         return NDR_ERR_SUCCESS;
1112 }
1113
1114 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
1115 {
1116         uint16_t v;
1117         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1118         *r = v;
1119         return NDR_ERR_SUCCESS;
1120 }
1121
1122 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
1123 {
1124         const char *val = NULL;
1125
1126         switch (r) {
1127                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
1128                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
1129         }
1130         ndr_print_enum(ndr, name, "ENUM", val, r);
1131 }
1132
1133 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
1134 {
1135         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1136         return NDR_ERR_SUCCESS;
1137 }
1138
1139 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
1140 {
1141         uint16_t v;
1142         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1143         *r = v;
1144         return NDR_ERR_SUCCESS;
1145 }
1146
1147 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
1148 {
1149         const char *val = NULL;
1150
1151         switch (r) {
1152                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
1153                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
1154                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
1155         }
1156         ndr_print_enum(ndr, name, "ENUM", val, r);
1157 }
1158
1159 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
1160 {
1161         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1162         return NDR_ERR_SUCCESS;
1163 }
1164
1165 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
1166 {
1167         uint16_t v;
1168         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1169         *r = v;
1170         return NDR_ERR_SUCCESS;
1171 }
1172
1173 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
1174 {
1175         const char *val = NULL;
1176
1177         switch (r) {
1178                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
1179                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
1180                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
1181                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
1182         }
1183         ndr_print_enum(ndr, name, "ENUM", val, r);
1184 }
1185
1186 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
1187 {
1188         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
1189         return NDR_ERR_SUCCESS;
1190 }
1191
1192 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
1193 {
1194         uint16_t v;
1195         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
1196         *r = v;
1197         return NDR_ERR_SUCCESS;
1198 }
1199
1200 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
1201 {
1202         const char *val = NULL;
1203
1204         switch (r) {
1205                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
1206                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
1207         }
1208         ndr_print_enum(ndr, name, "ENUM", val, r);
1209 }
1210
1211 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
1212 {
1213         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
1218 {
1219         uint32_t v;
1220         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1221         *r = v;
1222         return NDR_ERR_SUCCESS;
1223 }
1224
1225 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
1226 {
1227         const char *val = NULL;
1228
1229         switch (r) {
1230                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
1231                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
1232         }
1233         ndr_print_enum(ndr, name, "ENUM", val, r);
1234 }
1235
1236 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
1237 {
1238         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1239         return NDR_ERR_SUCCESS;
1240 }
1241
1242 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
1243 {
1244         uint32_t v;
1245         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1246         *r = v;
1247         return NDR_ERR_SUCCESS;
1248 }
1249
1250 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
1251 {
1252         const char *val = NULL;
1253
1254         switch (r) {
1255                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
1256                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
1257                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
1258                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
1259         }
1260         ndr_print_enum(ndr, name, "ENUM", val, r);
1261 }
1262
1263 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
1264 {
1265         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1266         return NDR_ERR_SUCCESS;
1267 }
1268
1269 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
1270 {
1271         uint32_t v;
1272         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1273         *r = v;
1274         return NDR_ERR_SUCCESS;
1275 }
1276
1277 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
1278 {
1279         const char *val = NULL;
1280
1281         switch (r) {
1282                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
1283                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
1284                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
1285                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
1286         }
1287         ndr_print_enum(ndr, name, "ENUM", val, r);
1288 }
1289
1290 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
1291 {
1292         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1293         return NDR_ERR_SUCCESS;
1294 }
1295
1296 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
1297 {
1298         uint32_t v;
1299         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1300         *r = v;
1301         return NDR_ERR_SUCCESS;
1302 }
1303
1304 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1305 {
1306         const char *val = NULL;
1307
1308         switch (r) {
1309                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1310                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1311                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1312         }
1313         ndr_print_enum(ndr, name, "ENUM", val, r);
1314 }
1315
1316 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1317 {
1318         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1319         return NDR_ERR_SUCCESS;
1320 }
1321
1322 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1323 {
1324         uint32_t v;
1325         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1326         *r = v;
1327         return NDR_ERR_SUCCESS;
1328 }
1329
1330 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1331 {
1332         const char *val = NULL;
1333
1334         switch (r) {
1335                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1336                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1337                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1338                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1339                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1340                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1341                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1342                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1343                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1344                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1345         }
1346         ndr_print_enum(ndr, name, "ENUM", val, r);
1347 }
1348
1349 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1350 {
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_push_align(ndr, 4));
1353                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1354                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1355                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1356                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1357                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1358                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1359                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1360                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1361                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1362                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1363                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1364                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1365                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1366                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1367                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1368                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1369                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1370                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1371                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1372                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1373                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1377                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1379                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1380                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1381                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1382                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1384                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1387                 {
1388                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1390                         {
1391                                 struct ndr_push *_ndr_driverextra_data;
1392                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1393                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1394                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1395                         }
1396                         ndr->flags = _flags_save_DATA_BLOB;
1397                 }
1398                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1399         }
1400         if (ndr_flags & NDR_BUFFERS) {
1401         }
1402         return NDR_ERR_SUCCESS;
1403 }
1404
1405 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1406 {
1407         if (ndr_flags & NDR_SCALARS) {
1408                 NDR_CHECK(ndr_pull_align(ndr, 4));
1409                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1410                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1411                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1412                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1413                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1414                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1415                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1416                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1417                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1418                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1419                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1420                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1421                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1422                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1423                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1424                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1425                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1426                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1427                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1428                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1433                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1435                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1436                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1437                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1438                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1443                 {
1444                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1446                         {
1447                                 struct ndr_pull *_ndr_driverextra_data;
1448                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1449                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1450                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1451                         }
1452                         ndr->flags = _flags_save_DATA_BLOB;
1453                 }
1454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1455         }
1456         if (ndr_flags & NDR_BUFFERS) {
1457         }
1458         return NDR_ERR_SUCCESS;
1459 }
1460
1461 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1462 {
1463         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1464         ndr->depth++;
1465         ndr_print_string(ndr, "devicename", r->devicename);
1466         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1467         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1468         ndr_print_uint16(ndr, "size", r->size);
1469         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1470         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1471         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1472         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1473         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1474         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1475         ndr_print_uint16(ndr, "scale", r->scale);
1476         ndr_print_uint16(ndr, "copies", r->copies);
1477         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1478         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1479         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1480         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1481         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1482         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1483         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1484         ndr_print_string(ndr, "formname", r->formname);
1485         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1486         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1487         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1488         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1489         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1490         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1491         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1492         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1493         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1494         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1495         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1496         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1497         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1498         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1499         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1500         ndr->depth--;
1501 }
1502
1503 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1504 {
1505         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1506 }
1507
1508 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1509 {
1510         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1511         return NDR_ERR_SUCCESS;
1512 }
1513
1514 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1515 {
1516         uint32_t v;
1517         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1518         *r = v;
1519         return NDR_ERR_SUCCESS;
1520 }
1521
1522 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1523 {
1524         ndr_print_uint32(ndr, name, r);
1525         ndr->depth++;
1526         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1527         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1528         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1529         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1530         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1531         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1532         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1545         ndr->depth--;
1546 }
1547
1548 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1549 {
1550         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1551         return NDR_ERR_SUCCESS;
1552 }
1553
1554 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1555 {
1556         uint32_t v;
1557         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1558         *r = v;
1559         return NDR_ERR_SUCCESS;
1560 }
1561
1562 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1563 {
1564         ndr_print_uint32(ndr, name, r);
1565         ndr->depth++;
1566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1580         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1581         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1582         ndr->depth--;
1583 }
1584
1585 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1586 {
1587         if (ndr_flags & NDR_SCALARS) {
1588                 NDR_CHECK(ndr_push_align(ndr, 5));
1589                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1590                 {
1591                         uint32_t _flags_save_string = ndr->flags;
1592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1594                         ndr->flags = _flags_save_string;
1595                 }
1596                 {
1597                         uint32_t _flags_save_string = ndr->flags;
1598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1600                         ndr->flags = _flags_save_string;
1601                 }
1602                 {
1603                         uint32_t _flags_save_string = ndr->flags;
1604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1606                         ndr->flags = _flags_save_string;
1607                 }
1608                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1609         }
1610         if (ndr_flags & NDR_BUFFERS) {
1611                 {
1612                         uint32_t _flags_save_string = ndr->flags;
1613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1614                         if (r->description) {
1615                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
1616                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1617                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
1618                         }
1619                         ndr->flags = _flags_save_string;
1620                 }
1621                 {
1622                         uint32_t _flags_save_string = ndr->flags;
1623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1624                         if (r->name) {
1625                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name));
1626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1627                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name));
1628                         }
1629                         ndr->flags = _flags_save_string;
1630                 }
1631                 {
1632                         uint32_t _flags_save_string = ndr->flags;
1633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1634                         if (r->comment) {
1635                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->comment));
1636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1637                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->comment));
1638                         }
1639                         ndr->flags = _flags_save_string;
1640                 }
1641         }
1642         return NDR_ERR_SUCCESS;
1643 }
1644
1645 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1646 {
1647         uint32_t _ptr_description;
1648         TALLOC_CTX *_mem_save_description_0;
1649         uint32_t _ptr_name;
1650         TALLOC_CTX *_mem_save_name_0;
1651         uint32_t _ptr_comment;
1652         TALLOC_CTX *_mem_save_comment_0;
1653         if (ndr_flags & NDR_SCALARS) {
1654                 NDR_CHECK(ndr_pull_align(ndr, 5));
1655                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1656                 {
1657                         uint32_t _flags_save_string = ndr->flags;
1658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1659                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1660                         if (_ptr_description) {
1661                                 NDR_PULL_ALLOC(ndr, r->description);
1662                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1663                         } else {
1664                                 r->description = NULL;
1665                         }
1666                         ndr->flags = _flags_save_string;
1667                 }
1668                 {
1669                         uint32_t _flags_save_string = ndr->flags;
1670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1672                         if (_ptr_name) {
1673                                 NDR_PULL_ALLOC(ndr, r->name);
1674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1675                         } else {
1676                                 r->name = NULL;
1677                         }
1678                         ndr->flags = _flags_save_string;
1679                 }
1680                 {
1681                         uint32_t _flags_save_string = ndr->flags;
1682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1684                         if (_ptr_comment) {
1685                                 NDR_PULL_ALLOC(ndr, r->comment);
1686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1687                         } else {
1688                                 r->comment = NULL;
1689                         }
1690                         ndr->flags = _flags_save_string;
1691                 }
1692                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1693         }
1694         if (ndr_flags & NDR_BUFFERS) {
1695                 {
1696                         uint32_t _flags_save_string = ndr->flags;
1697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1698                         if (r->description) {
1699                                 uint32_t _relative_save_offset;
1700                                 _relative_save_offset = ndr->offset;
1701                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1702                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1703                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1704                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1705                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1706                                 if (ndr->offset > ndr->relative_highest_offset) {
1707                                         ndr->relative_highest_offset = ndr->offset;
1708                                 }
1709                                 ndr->offset = _relative_save_offset;
1710                         }
1711                         ndr->flags = _flags_save_string;
1712                 }
1713                 {
1714                         uint32_t _flags_save_string = ndr->flags;
1715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1716                         if (r->name) {
1717                                 uint32_t _relative_save_offset;
1718                                 _relative_save_offset = ndr->offset;
1719                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1720                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1721                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1722                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1723                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1724                                 if (ndr->offset > ndr->relative_highest_offset) {
1725                                         ndr->relative_highest_offset = ndr->offset;
1726                                 }
1727                                 ndr->offset = _relative_save_offset;
1728                         }
1729                         ndr->flags = _flags_save_string;
1730                 }
1731                 {
1732                         uint32_t _flags_save_string = ndr->flags;
1733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1734                         if (r->comment) {
1735                                 uint32_t _relative_save_offset;
1736                                 _relative_save_offset = ndr->offset;
1737                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1738                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1739                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1740                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1741                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1742                                 if (ndr->offset > ndr->relative_highest_offset) {
1743                                         ndr->relative_highest_offset = ndr->offset;
1744                                 }
1745                                 ndr->offset = _relative_save_offset;
1746                         }
1747                         ndr->flags = _flags_save_string;
1748                 }
1749         }
1750         return NDR_ERR_SUCCESS;
1751 }
1752
1753 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1754 {
1755         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1756         ndr->depth++;
1757         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1758         ndr_print_ptr(ndr, "description", r->description);
1759         ndr->depth++;
1760         if (r->description) {
1761                 ndr_print_string(ndr, "description", r->description);
1762         }
1763         ndr->depth--;
1764         ndr_print_ptr(ndr, "name", r->name);
1765         ndr->depth++;
1766         if (r->name) {
1767                 ndr_print_string(ndr, "name", r->name);
1768         }
1769         ndr->depth--;
1770         ndr_print_ptr(ndr, "comment", r->comment);
1771         ndr->depth++;
1772         if (r->comment) {
1773                 ndr_print_string(ndr, "comment", r->comment);
1774         }
1775         ndr->depth--;
1776         ndr->depth--;
1777 }
1778
1779 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1780 {
1781         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1782 }
1783
1784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1785 {
1786         uint32_t _ptr_servername;
1787         TALLOC_CTX *_mem_save_servername_0;
1788         uint32_t _ptr_printername;
1789         TALLOC_CTX *_mem_save_printername_0;
1790         uint32_t _ptr_sharename;
1791         TALLOC_CTX *_mem_save_sharename_0;
1792         uint32_t _ptr_portname;
1793         TALLOC_CTX *_mem_save_portname_0;
1794         uint32_t _ptr_drivername;
1795         TALLOC_CTX *_mem_save_drivername_0;
1796         uint32_t _ptr_comment;
1797         TALLOC_CTX *_mem_save_comment_0;
1798         uint32_t _ptr_location;
1799         TALLOC_CTX *_mem_save_location_0;
1800         uint32_t _ptr_devmode;
1801         TALLOC_CTX *_mem_save_devmode_0;
1802         uint32_t _ptr_sepfile;
1803         TALLOC_CTX *_mem_save_sepfile_0;
1804         uint32_t _ptr_printprocessor;
1805         TALLOC_CTX *_mem_save_printprocessor_0;
1806         uint32_t _ptr_datatype;
1807         TALLOC_CTX *_mem_save_datatype_0;
1808         uint32_t _ptr_parameters;
1809         TALLOC_CTX *_mem_save_parameters_0;
1810         uint32_t _ptr_secdesc;
1811         TALLOC_CTX *_mem_save_secdesc_0;
1812         if (ndr_flags & NDR_SCALARS) {
1813                 NDR_CHECK(ndr_pull_align(ndr, 5));
1814                 {
1815                         uint32_t _flags_save_string = ndr->flags;
1816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1817                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1818                         if (_ptr_servername) {
1819                                 NDR_PULL_ALLOC(ndr, r->servername);
1820                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1821                         } else {
1822                                 r->servername = NULL;
1823                         }
1824                         ndr->flags = _flags_save_string;
1825                 }
1826                 {
1827                         uint32_t _flags_save_string = ndr->flags;
1828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1830                         if (_ptr_printername) {
1831                                 NDR_PULL_ALLOC(ndr, r->printername);
1832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1833                         } else {
1834                                 r->printername = NULL;
1835                         }
1836                         ndr->flags = _flags_save_string;
1837                 }
1838                 {
1839                         uint32_t _flags_save_string = ndr->flags;
1840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1842                         if (_ptr_sharename) {
1843                                 NDR_PULL_ALLOC(ndr, r->sharename);
1844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1845                         } else {
1846                                 r->sharename = NULL;
1847                         }
1848                         ndr->flags = _flags_save_string;
1849                 }
1850                 {
1851                         uint32_t _flags_save_string = ndr->flags;
1852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1854                         if (_ptr_portname) {
1855                                 NDR_PULL_ALLOC(ndr, r->portname);
1856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1857                         } else {
1858                                 r->portname = NULL;
1859                         }
1860                         ndr->flags = _flags_save_string;
1861                 }
1862                 {
1863                         uint32_t _flags_save_string = ndr->flags;
1864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1866                         if (_ptr_drivername) {
1867                                 NDR_PULL_ALLOC(ndr, r->drivername);
1868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1869                         } else {
1870                                 r->drivername = NULL;
1871                         }
1872                         ndr->flags = _flags_save_string;
1873                 }
1874                 {
1875                         uint32_t _flags_save_string = ndr->flags;
1876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1877                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1878                         if (_ptr_comment) {
1879                                 NDR_PULL_ALLOC(ndr, r->comment);
1880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1881                         } else {
1882                                 r->comment = NULL;
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1890                         if (_ptr_location) {
1891                                 NDR_PULL_ALLOC(ndr, r->location);
1892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1893                         } else {
1894                                 r->location = NULL;
1895                         }
1896                         ndr->flags = _flags_save_string;
1897                 }
1898                 {
1899                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
1900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1902                         if (_ptr_devmode) {
1903                                 NDR_PULL_ALLOC(ndr, r->devmode);
1904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1905                         } else {
1906                                 r->devmode = NULL;
1907                         }
1908                         ndr->flags = _flags_save_spoolss_DeviceMode;
1909                 }
1910                 {
1911                         uint32_t _flags_save_string = ndr->flags;
1912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1914                         if (_ptr_sepfile) {
1915                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1917                         } else {
1918                                 r->sepfile = NULL;
1919                         }
1920                         ndr->flags = _flags_save_string;
1921                 }
1922                 {
1923                         uint32_t _flags_save_string = ndr->flags;
1924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1926                         if (_ptr_printprocessor) {
1927                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1929                         } else {
1930                                 r->printprocessor = NULL;
1931                         }
1932                         ndr->flags = _flags_save_string;
1933                 }
1934                 {
1935                         uint32_t _flags_save_string = ndr->flags;
1936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1937                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1938                         if (_ptr_datatype) {
1939                                 NDR_PULL_ALLOC(ndr, r->datatype);
1940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1941                         } else {
1942                                 r->datatype = NULL;
1943                         }
1944                         ndr->flags = _flags_save_string;
1945                 }
1946                 {
1947                         uint32_t _flags_save_string = ndr->flags;
1948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1950                         if (_ptr_parameters) {
1951                                 NDR_PULL_ALLOC(ndr, r->parameters);
1952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1953                         } else {
1954                                 r->parameters = NULL;
1955                         }
1956                         ndr->flags = _flags_save_string;
1957                 }
1958                 {
1959                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
1960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
1961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1962                         if (_ptr_secdesc) {
1963                                 NDR_PULL_ALLOC(ndr, r->secdesc);
1964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1965                         } else {
1966                                 r->secdesc = NULL;
1967                         }
1968                         ndr->flags = _flags_save_spoolss_security_descriptor;
1969                 }
1970                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1972                 if (r->priority > 99) {
1973                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1974                 }
1975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1978                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1981                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1982         }
1983         if (ndr_flags & NDR_BUFFERS) {
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->servername) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1991                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 {
2003                         uint32_t _flags_save_string = ndr->flags;
2004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2005                         if (r->printername) {
2006                                 uint32_t _relative_save_offset;
2007                                 _relative_save_offset = ndr->offset;
2008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2009                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2010                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2013                                 if (ndr->offset > ndr->relative_highest_offset) {
2014                                         ndr->relative_highest_offset = ndr->offset;
2015                                 }
2016                                 ndr->offset = _relative_save_offset;
2017                         }
2018                         ndr->flags = _flags_save_string;
2019                 }
2020                 {
2021                         uint32_t _flags_save_string = ndr->flags;
2022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2023                         if (r->sharename) {
2024                                 uint32_t _relative_save_offset;
2025                                 _relative_save_offset = ndr->offset;
2026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
2027                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
2028                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
2029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
2030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_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->portname) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2045                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_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->drivername) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
2063                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_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->comment) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
2081                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 {
2093                         uint32_t _flags_save_string = ndr->flags;
2094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2095                         if (r->location) {
2096                                 uint32_t _relative_save_offset;
2097                                 _relative_save_offset = ndr->offset;
2098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
2099                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
2100                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
2101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
2102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
2103                                 if (ndr->offset > ndr->relative_highest_offset) {
2104                                         ndr->relative_highest_offset = ndr->offset;
2105                                 }
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110                 {
2111                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2113                         if (r->devmode) {
2114                                 uint32_t _relative_save_offset;
2115                                 _relative_save_offset = ndr->offset;
2116                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2117                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2118                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2119                                 {
2120                                         struct ndr_pull *_ndr_devmode;
2121                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2122                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2123                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2124                                 }
2125                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2126                                 if (ndr->offset > ndr->relative_highest_offset) {
2127                                         ndr->relative_highest_offset = ndr->offset;
2128                                 }
2129                                 ndr->offset = _relative_save_offset;
2130                         }
2131                         ndr->flags = _flags_save_spoolss_DeviceMode;
2132                 }
2133                 {
2134                         uint32_t _flags_save_string = ndr->flags;
2135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2136                         if (r->sepfile) {
2137                                 uint32_t _relative_save_offset;
2138                                 _relative_save_offset = ndr->offset;
2139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2140                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2141                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2144                                 if (ndr->offset > ndr->relative_highest_offset) {
2145                                         ndr->relative_highest_offset = ndr->offset;
2146                                 }
2147                                 ndr->offset = _relative_save_offset;
2148                         }
2149                         ndr->flags = _flags_save_string;
2150                 }
2151                 {
2152                         uint32_t _flags_save_string = ndr->flags;
2153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2154                         if (r->printprocessor) {
2155                                 uint32_t _relative_save_offset;
2156                                 _relative_save_offset = ndr->offset;
2157                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2158                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2159                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2160                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2161                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2162                                 if (ndr->offset > ndr->relative_highest_offset) {
2163                                         ndr->relative_highest_offset = ndr->offset;
2164                                 }
2165                                 ndr->offset = _relative_save_offset;
2166                         }
2167                         ndr->flags = _flags_save_string;
2168                 }
2169                 {
2170                         uint32_t _flags_save_string = ndr->flags;
2171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2172                         if (r->datatype) {
2173                                 uint32_t _relative_save_offset;
2174                                 _relative_save_offset = ndr->offset;
2175                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2176                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2177                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2178                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2179                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2180                                 if (ndr->offset > ndr->relative_highest_offset) {
2181                                         ndr->relative_highest_offset = ndr->offset;
2182                                 }
2183                                 ndr->offset = _relative_save_offset;
2184                         }
2185                         ndr->flags = _flags_save_string;
2186                 }
2187                 {
2188                         uint32_t _flags_save_string = ndr->flags;
2189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2190                         if (r->parameters) {
2191                                 uint32_t _relative_save_offset;
2192                                 _relative_save_offset = ndr->offset;
2193                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2194                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2195                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2196                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2197                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2198                                 if (ndr->offset > ndr->relative_highest_offset) {
2199                                         ndr->relative_highest_offset = ndr->offset;
2200                                 }
2201                                 ndr->offset = _relative_save_offset;
2202                         }
2203                         ndr->flags = _flags_save_string;
2204                 }
2205                 {
2206                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2208                         if (r->secdesc) {
2209                                 uint32_t _relative_save_offset;
2210                                 _relative_save_offset = ndr->offset;
2211                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2212                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2213                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2214                                 {
2215                                         struct ndr_pull *_ndr_secdesc;
2216                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2217                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2218                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2219                                 }
2220                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2221                                 if (ndr->offset > ndr->relative_highest_offset) {
2222                                         ndr->relative_highest_offset = ndr->offset;
2223                                 }
2224                                 ndr->offset = _relative_save_offset;
2225                         }
2226                         ndr->flags = _flags_save_spoolss_security_descriptor;
2227                 }
2228         }
2229         return NDR_ERR_SUCCESS;
2230 }
2231
2232 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2233 {
2234         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2235         ndr->depth++;
2236         ndr_print_ptr(ndr, "servername", r->servername);
2237         ndr->depth++;
2238         if (r->servername) {
2239                 ndr_print_string(ndr, "servername", r->servername);
2240         }
2241         ndr->depth--;
2242         ndr_print_ptr(ndr, "printername", r->printername);
2243         ndr->depth++;
2244         if (r->printername) {
2245                 ndr_print_string(ndr, "printername", r->printername);
2246         }
2247         ndr->depth--;
2248         ndr_print_ptr(ndr, "sharename", r->sharename);
2249         ndr->depth++;
2250         if (r->sharename) {
2251                 ndr_print_string(ndr, "sharename", r->sharename);
2252         }
2253         ndr->depth--;
2254         ndr_print_ptr(ndr, "portname", r->portname);
2255         ndr->depth++;
2256         if (r->portname) {
2257                 ndr_print_string(ndr, "portname", r->portname);
2258         }
2259         ndr->depth--;
2260         ndr_print_ptr(ndr, "drivername", r->drivername);
2261         ndr->depth++;
2262         if (r->drivername) {
2263                 ndr_print_string(ndr, "drivername", r->drivername);
2264         }
2265         ndr->depth--;
2266         ndr_print_ptr(ndr, "comment", r->comment);
2267         ndr->depth++;
2268         if (r->comment) {
2269                 ndr_print_string(ndr, "comment", r->comment);
2270         }
2271         ndr->depth--;
2272         ndr_print_ptr(ndr, "location", r->location);
2273         ndr->depth++;
2274         if (r->location) {
2275                 ndr_print_string(ndr, "location", r->location);
2276         }
2277         ndr->depth--;
2278         ndr_print_ptr(ndr, "devmode", r->devmode);
2279         ndr->depth++;
2280         if (r->devmode) {
2281                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2282         }
2283         ndr->depth--;
2284         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2285         ndr->depth++;
2286         if (r->sepfile) {
2287                 ndr_print_string(ndr, "sepfile", r->sepfile);
2288         }
2289         ndr->depth--;
2290         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2291         ndr->depth++;
2292         if (r->printprocessor) {
2293                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2294         }
2295         ndr->depth--;
2296         ndr_print_ptr(ndr, "datatype", r->datatype);
2297         ndr->depth++;
2298         if (r->datatype) {
2299                 ndr_print_string(ndr, "datatype", r->datatype);
2300         }
2301         ndr->depth--;
2302         ndr_print_ptr(ndr, "parameters", r->parameters);
2303         ndr->depth++;
2304         if (r->parameters) {
2305                 ndr_print_string(ndr, "parameters", r->parameters);
2306         }
2307         ndr->depth--;
2308         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2309         ndr->depth++;
2310         if (r->secdesc) {
2311                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2312         }
2313         ndr->depth--;
2314         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2315         ndr_print_uint32(ndr, "priority", r->priority);
2316         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2317         ndr_print_uint32(ndr, "starttime", r->starttime);
2318         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2319         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2320         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2321         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2322         ndr->depth--;
2323 }
2324
2325 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2326 {
2327         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2328 }
2329
2330 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2331 {
2332         if (ndr_flags & NDR_SCALARS) {
2333                 NDR_CHECK(ndr_push_align(ndr, 5));
2334                 {
2335                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2337                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2338                         ndr->flags = _flags_save_spoolss_security_descriptor;
2339                 }
2340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2341         }
2342         if (ndr_flags & NDR_BUFFERS) {
2343                 {
2344                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2346                         if (r->secdesc) {
2347                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
2348                                 {
2349                                         struct ndr_push *_ndr_secdesc;
2350                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2351                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2352                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2353                                 }
2354                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
2355                         }
2356                         ndr->flags = _flags_save_spoolss_security_descriptor;
2357                 }
2358         }
2359         return NDR_ERR_SUCCESS;
2360 }
2361
2362 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2363 {
2364         uint32_t _ptr_secdesc;
2365         TALLOC_CTX *_mem_save_secdesc_0;
2366         if (ndr_flags & NDR_SCALARS) {
2367                 NDR_CHECK(ndr_pull_align(ndr, 5));
2368                 {
2369                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2371                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2372                         if (_ptr_secdesc) {
2373                                 NDR_PULL_ALLOC(ndr, r->secdesc);
2374                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2375                         } else {
2376                                 r->secdesc = NULL;
2377                         }
2378                         ndr->flags = _flags_save_spoolss_security_descriptor;
2379                 }
2380                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2381         }
2382         if (ndr_flags & NDR_BUFFERS) {
2383                 {
2384                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
2385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2386                         if (r->secdesc) {
2387                                 uint32_t _relative_save_offset;
2388                                 _relative_save_offset = ndr->offset;
2389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2390                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2391                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2392                                 {
2393                                         struct ndr_pull *_ndr_secdesc;
2394                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2395                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2396                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2397                                 }
2398                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2399                                 if (ndr->offset > ndr->relative_highest_offset) {
2400                                         ndr->relative_highest_offset = ndr->offset;
2401                                 }
2402                                 ndr->offset = _relative_save_offset;
2403                         }
2404                         ndr->flags = _flags_save_spoolss_security_descriptor;
2405                 }
2406         }
2407         return NDR_ERR_SUCCESS;
2408 }
2409
2410 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2411 {
2412         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2413         ndr->depth++;
2414         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2415         ndr->depth++;
2416         if (r->secdesc) {
2417                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
2418         }
2419         ndr->depth--;
2420         ndr->depth--;
2421 }
2422
2423 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2424 {
2425         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2426 }
2427
2428 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2429 {
2430         if (ndr_flags & NDR_SCALARS) {
2431                 NDR_CHECK(ndr_push_align(ndr, 5));
2432                 {
2433                         uint32_t _flags_save_string = ndr->flags;
2434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2436                         ndr->flags = _flags_save_string;
2437                 }
2438                 {
2439                         uint32_t _flags_save_string = ndr->flags;
2440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2442                         ndr->flags = _flags_save_string;
2443                 }
2444                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2445                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2446         }
2447         if (ndr_flags & NDR_BUFFERS) {
2448                 {
2449                         uint32_t _flags_save_string = ndr->flags;
2450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2451                         if (r->printername) {
2452                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2453                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2454                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2455                         }
2456                         ndr->flags = _flags_save_string;
2457                 }
2458                 {
2459                         uint32_t _flags_save_string = ndr->flags;
2460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2461                         if (r->servername) {
2462                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->servername));
2463                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2464                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->servername));
2465                         }
2466                         ndr->flags = _flags_save_string;
2467                 }
2468         }
2469         return NDR_ERR_SUCCESS;
2470 }
2471
2472 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2473 {
2474         uint32_t _ptr_printername;
2475         TALLOC_CTX *_mem_save_printername_0;
2476         uint32_t _ptr_servername;
2477         TALLOC_CTX *_mem_save_servername_0;
2478         if (ndr_flags & NDR_SCALARS) {
2479                 NDR_CHECK(ndr_pull_align(ndr, 5));
2480                 {
2481                         uint32_t _flags_save_string = ndr->flags;
2482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2483                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2484                         if (_ptr_printername) {
2485                                 NDR_PULL_ALLOC(ndr, r->printername);
2486                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2487                         } else {
2488                                 r->printername = NULL;
2489                         }
2490                         ndr->flags = _flags_save_string;
2491                 }
2492                 {
2493                         uint32_t _flags_save_string = ndr->flags;
2494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2495                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2496                         if (_ptr_servername) {
2497                                 NDR_PULL_ALLOC(ndr, r->servername);
2498                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2499                         } else {
2500                                 r->servername = NULL;
2501                         }
2502                         ndr->flags = _flags_save_string;
2503                 }
2504                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2505                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2506         }
2507         if (ndr_flags & NDR_BUFFERS) {
2508                 {
2509                         uint32_t _flags_save_string = ndr->flags;
2510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2511                         if (r->printername) {
2512                                 uint32_t _relative_save_offset;
2513                                 _relative_save_offset = ndr->offset;
2514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2515                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2516                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2519                                 if (ndr->offset > ndr->relative_highest_offset) {
2520                                         ndr->relative_highest_offset = ndr->offset;
2521                                 }
2522                                 ndr->offset = _relative_save_offset;
2523                         }
2524                         ndr->flags = _flags_save_string;
2525                 }
2526                 {
2527                         uint32_t _flags_save_string = ndr->flags;
2528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2529                         if (r->servername) {
2530                                 uint32_t _relative_save_offset;
2531                                 _relative_save_offset = ndr->offset;
2532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2533                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2534                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2537                                 if (ndr->offset > ndr->relative_highest_offset) {
2538                                         ndr->relative_highest_offset = ndr->offset;
2539                                 }
2540                                 ndr->offset = _relative_save_offset;
2541                         }
2542                         ndr->flags = _flags_save_string;
2543                 }
2544         }
2545         return NDR_ERR_SUCCESS;
2546 }
2547
2548 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2549 {
2550         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2551         ndr->depth++;
2552         ndr_print_ptr(ndr, "printername", r->printername);
2553         ndr->depth++;
2554         if (r->printername) {
2555                 ndr_print_string(ndr, "printername", r->printername);
2556         }
2557         ndr->depth--;
2558         ndr_print_ptr(ndr, "servername", r->servername);
2559         ndr->depth++;
2560         if (r->servername) {
2561                 ndr_print_string(ndr, "servername", r->servername);
2562         }
2563         ndr->depth--;
2564         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2565         ndr->depth--;
2566 }
2567
2568 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2569 {
2570         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2571 }
2572
2573 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2574 {
2575         if (ndr_flags & NDR_SCALARS) {
2576                 NDR_CHECK(ndr_push_align(ndr, 5));
2577                 {
2578                         uint32_t _flags_save_string = ndr->flags;
2579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2580                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2581                         ndr->flags = _flags_save_string;
2582                 }
2583                 {
2584                         uint32_t _flags_save_string = ndr->flags;
2585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2586                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2587                         ndr->flags = _flags_save_string;
2588                 }
2589                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2592                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2593         }
2594         if (ndr_flags & NDR_BUFFERS) {
2595                 {
2596                         uint32_t _flags_save_string = ndr->flags;
2597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2598                         if (r->printername) {
2599                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printername));
2600                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2601                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printername));
2602                         }
2603                         ndr->flags = _flags_save_string;
2604                 }
2605                 {
2606                         uint32_t _flags_save_string = ndr->flags;
2607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2608                         if (r->portname) {
2609                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->portname));
2610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2611                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->portname));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615         }
2616         return NDR_ERR_SUCCESS;
2617 }
2618
2619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2620 {
2621         uint32_t _ptr_printername;
2622         TALLOC_CTX *_mem_save_printername_0;
2623         uint32_t _ptr_portname;
2624         TALLOC_CTX *_mem_save_portname_0;
2625         if (ndr_flags & NDR_SCALARS) {
2626                 NDR_CHECK(ndr_pull_align(ndr, 5));
2627                 {
2628                         uint32_t _flags_save_string = ndr->flags;
2629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2630                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2631                         if (_ptr_printername) {
2632                                 NDR_PULL_ALLOC(ndr, r->printername);
2633                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2634                         } else {
2635                                 r->printername = NULL;
2636                         }
2637                         ndr->flags = _flags_save_string;
2638                 }
2639                 {
2640                         uint32_t _flags_save_string = ndr->flags;
2641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2642                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2643                         if (_ptr_portname) {
2644                                 NDR_PULL_ALLOC(ndr, r->portname);
2645                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2646                         } else {
2647                                 r->portname = NULL;
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2654                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2655         }
2656         if (ndr_flags & NDR_BUFFERS) {
2657                 {
2658                         uint32_t _flags_save_string = ndr->flags;
2659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2660                         if (r->printername) {
2661                                 uint32_t _relative_save_offset;
2662                                 _relative_save_offset = ndr->offset;
2663                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2664                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2665                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2666                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2667                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2668                                 if (ndr->offset > ndr->relative_highest_offset) {
2669                                         ndr->relative_highest_offset = ndr->offset;
2670                                 }
2671                                 ndr->offset = _relative_save_offset;
2672                         }
2673                         ndr->flags = _flags_save_string;
2674                 }
2675                 {
2676                         uint32_t _flags_save_string = ndr->flags;
2677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2678                         if (r->portname) {
2679                                 uint32_t _relative_save_offset;
2680                                 _relative_save_offset = ndr->offset;
2681                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2682                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2683                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2684                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2685                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2686                                 if (ndr->offset > ndr->relative_highest_offset) {
2687                                         ndr->relative_highest_offset = ndr->offset;
2688                                 }
2689                                 ndr->offset = _relative_save_offset;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693         }
2694         return NDR_ERR_SUCCESS;
2695 }
2696
2697 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2698 {
2699         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2700         ndr->depth++;
2701         ndr_print_ptr(ndr, "printername", r->printername);
2702         ndr->depth++;
2703         if (r->printername) {
2704                 ndr_print_string(ndr, "printername", r->printername);
2705         }
2706         ndr->depth--;
2707         ndr_print_ptr(ndr, "portname", r->portname);
2708         ndr->depth++;
2709         if (r->portname) {
2710                 ndr_print_string(ndr, "portname", r->portname);
2711         }
2712         ndr->depth--;
2713         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2714         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2715         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2716         ndr->depth--;
2717 }
2718
2719 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2720 {
2721         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2722 }
2723
2724 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2725 {
2726         if (ndr_flags & NDR_SCALARS) {
2727                 NDR_CHECK(ndr_push_align(ndr, 4));
2728                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2729                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2730         }
2731         if (ndr_flags & NDR_BUFFERS) {
2732         }
2733         return NDR_ERR_SUCCESS;
2734 }
2735
2736 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2737 {
2738         if (ndr_flags & NDR_SCALARS) {
2739                 NDR_CHECK(ndr_pull_align(ndr, 4));
2740                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2741                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2742         }
2743         if (ndr_flags & NDR_BUFFERS) {
2744         }
2745         return NDR_ERR_SUCCESS;
2746 }
2747
2748 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2749 {
2750         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2751         ndr->depth++;
2752         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2753         ndr->depth--;
2754 }
2755
2756 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2757 {
2758         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2759 }
2760
2761 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2762 {
2763         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2764         return NDR_ERR_SUCCESS;
2765 }
2766
2767 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2768 {
2769         uint32_t v;
2770         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2771         *r = v;
2772         return NDR_ERR_SUCCESS;
2773 }
2774
2775 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2776 {
2777         ndr_print_uint32(ndr, name, r);
2778         ndr->depth++;
2779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2781         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2782         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2783         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2784         ndr->depth--;
2785 }
2786
2787 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2788 {
2789         if (ndr_flags & NDR_SCALARS) {
2790                 NDR_CHECK(ndr_push_align(ndr, 5));
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2795                         ndr->flags = _flags_save_string;
2796                 }
2797                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2799         }
2800         if (ndr_flags & NDR_BUFFERS) {
2801                 {
2802                         uint32_t _flags_save_string = ndr->flags;
2803                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2804                         if (r->guid) {
2805                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->guid));
2806                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2807                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->guid));
2808                         }
2809                         ndr->flags = _flags_save_string;
2810                 }
2811         }
2812         return NDR_ERR_SUCCESS;
2813 }
2814
2815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2816 {
2817         uint32_t _ptr_guid;
2818         TALLOC_CTX *_mem_save_guid_0;
2819         if (ndr_flags & NDR_SCALARS) {
2820                 NDR_CHECK(ndr_pull_align(ndr, 5));
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2825                         if (_ptr_guid) {
2826                                 NDR_PULL_ALLOC(ndr, r->guid);
2827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2828                         } else {
2829                                 r->guid = NULL;
2830                         }
2831                         ndr->flags = _flags_save_string;
2832                 }
2833                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2834                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2835         }
2836         if (ndr_flags & NDR_BUFFERS) {
2837                 {
2838                         uint32_t _flags_save_string = ndr->flags;
2839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2840                         if (r->guid) {
2841                                 uint32_t _relative_save_offset;
2842                                 _relative_save_offset = ndr->offset;
2843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2844                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2845                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2848                                 if (ndr->offset > ndr->relative_highest_offset) {
2849                                         ndr->relative_highest_offset = ndr->offset;
2850                                 }
2851                                 ndr->offset = _relative_save_offset;
2852                         }
2853                         ndr->flags = _flags_save_string;
2854                 }
2855         }
2856         return NDR_ERR_SUCCESS;
2857 }
2858
2859 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2860 {
2861         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2862         ndr->depth++;
2863         ndr_print_ptr(ndr, "guid", r->guid);
2864         ndr->depth++;
2865         if (r->guid) {
2866                 ndr_print_string(ndr, "guid", r->guid);
2867         }
2868         ndr->depth--;
2869         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2870         ndr->depth--;
2871 }
2872
2873 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2874 {
2875         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2876 }
2877
2878 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2879 {
2880         if (ndr_flags & NDR_SCALARS) {
2881                 NDR_CHECK(ndr_push_align(ndr, 5));
2882                 {
2883                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2885                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2886                         ndr->flags = _flags_save_spoolss_DeviceMode;
2887                 }
2888                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2889         }
2890         if (ndr_flags & NDR_BUFFERS) {
2891                 {
2892                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2894                         if (r->devmode) {
2895                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
2896                                 {
2897                                         struct ndr_push *_ndr_devmode;
2898                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2899                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2900                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2901                                 }
2902                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
2903                         }
2904                         ndr->flags = _flags_save_spoolss_DeviceMode;
2905                 }
2906         }
2907         return NDR_ERR_SUCCESS;
2908 }
2909
2910 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2911 {
2912         uint32_t _ptr_devmode;
2913         TALLOC_CTX *_mem_save_devmode_0;
2914         if (ndr_flags & NDR_SCALARS) {
2915                 NDR_CHECK(ndr_pull_align(ndr, 5));
2916                 {
2917                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2920                         if (_ptr_devmode) {
2921                                 NDR_PULL_ALLOC(ndr, r->devmode);
2922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2923                         } else {
2924                                 r->devmode = NULL;
2925                         }
2926                         ndr->flags = _flags_save_spoolss_DeviceMode;
2927                 }
2928                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2929         }
2930         if (ndr_flags & NDR_BUFFERS) {
2931                 {
2932                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
2933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
2934                         if (r->devmode) {
2935                                 uint32_t _relative_save_offset;
2936                                 _relative_save_offset = ndr->offset;
2937                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2938                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2939                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2940                                 {
2941                                         struct ndr_pull *_ndr_devmode;
2942                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2943                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2944                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2945                                 }
2946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2947                                 if (ndr->offset > ndr->relative_highest_offset) {
2948                                         ndr->relative_highest_offset = ndr->offset;
2949                                 }
2950                                 ndr->offset = _relative_save_offset;
2951                         }
2952                         ndr->flags = _flags_save_spoolss_DeviceMode;
2953                 }
2954         }
2955         return NDR_ERR_SUCCESS;
2956 }
2957
2958 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2959 {
2960         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2961         ndr->depth++;
2962         ndr_print_ptr(ndr, "devmode", r->devmode);
2963         ndr->depth++;
2964         if (r->devmode) {
2965                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2966         }
2967         ndr->depth--;
2968         ndr->depth--;
2969 }
2970
2971 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2972 {
2973         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2974         {
2975                 uint32_t _flags_save_UNION = ndr->flags;
2976                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
2977                 if (ndr_flags & NDR_SCALARS) {
2978                         int level = ndr_push_get_switch_value(ndr, r);
2979                         NDR_CHECK(ndr_push_union_align(ndr, 5));
2980                         switch (level) {
2981                                 case 0: {
2982                                         NDR_CHECK(ndr_push_align(ndr, 5));
2983                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2984                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2985                                 break; }
2986
2987                                 case 1: {
2988                                         NDR_CHECK(ndr_push_align(ndr, 5));
2989                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2990                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2991                                 break; }
2992
2993                                 case 2: {
2994                                         NDR_CHECK(ndr_push_align(ndr, 5));
2995                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2996                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2997                                 break; }
2998
2999                                 case 3: {
3000                                         NDR_CHECK(ndr_push_align(ndr, 5));
3001                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3002                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
3003                                 break; }
3004
3005                                 case 4: {
3006                                         NDR_CHECK(ndr_push_align(ndr, 5));
3007                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3008                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
3009                                 break; }
3010
3011                                 case 5: {
3012                                         NDR_CHECK(ndr_push_align(ndr, 5));
3013                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3014                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
3015                                 break; }
3016
3017                                 case 6: {
3018                                         NDR_CHECK(ndr_push_align(ndr, 4));
3019                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3020                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
3021                                 break; }
3022
3023                                 case 7: {
3024                                         NDR_CHECK(ndr_push_align(ndr, 5));
3025                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3026                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
3027                                 break; }
3028
3029                                 case 8: {
3030                                         NDR_CHECK(ndr_push_align(ndr, 5));
3031                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3032                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
3033                                 break; }
3034
3035                                 case 9: {
3036                                         NDR_CHECK(ndr_push_align(ndr, 5));
3037                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
3038                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
3039                                 break; }
3040
3041                                 default: {
3042                                 break; }
3043
3044                         }
3045                 }
3046                 if (ndr_flags & NDR_BUFFERS) {
3047                         int level = ndr_push_get_switch_value(ndr, r);
3048                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
3049                         switch (level) {
3050                                 case 0:
3051                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3052                                 break;
3053
3054                                 case 1:
3055                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3056                                 break;
3057
3058                                 case 2:
3059                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3060                                 break;
3061
3062                                 case 3:
3063                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3064                                 break;
3065
3066                                 case 4:
3067                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3068                                 break;
3069
3070                                 case 5:
3071                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3072                                 break;
3073
3074                                 case 6:
3075                                 break;
3076
3077                                 case 7:
3078                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3079                                 break;
3080
3081                                 case 8:
3082                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3083                                 break;
3084
3085                                 case 9:
3086                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3087                                 break;
3088
3089                                 default:
3090                                 break;
3091
3092                         }
3093                 }
3094                 ndr->flags = _flags_save_UNION;
3095         }
3096         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
3097         return NDR_ERR_SUCCESS;
3098 }
3099
3100 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
3101 {
3102         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
3103         int level;
3104         {
3105                 uint32_t _flags_save_UNION = ndr->flags;
3106                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
3107                 level = ndr_pull_get_switch_value(ndr, r);
3108                 if (ndr_flags & NDR_SCALARS) {
3109                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3110                         switch (level) {
3111                                 case 0: {
3112                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3113                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3114                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
3115                                 break; }
3116
3117                                 case 1: {
3118                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3119                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3120                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
3121                                 break; }
3122
3123                                 case 2: {
3124                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3125                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3126                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
3127                                 break; }
3128
3129                                 case 3: {
3130                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3131                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3132                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
3133                                 break; }
3134
3135                                 case 4: {
3136                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3137                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3138                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
3139                                 break; }
3140
3141                                 case 5: {
3142                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3143                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3144                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
3145                                 break; }
3146
3147                                 case 6: {
3148                                         NDR_CHECK(ndr_pull_align(ndr, 4));
3149                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3150                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
3151                                 break; }
3152
3153                                 case 7: {
3154                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3155                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3156                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
3157                                 break; }
3158
3159                                 case 8: {
3160                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3161                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3162                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
3163                                 break; }
3164
3165                                 case 9: {
3166                                         NDR_CHECK(ndr_pull_align(ndr, 5));
3167                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
3168                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
3169                                 break; }
3170
3171                                 default: {
3172                                 break; }
3173
3174                         }
3175                 }
3176                 if (ndr_flags & NDR_BUFFERS) {
3177                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3178                         switch (level) {
3179                                 case 0:
3180                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3181                                 break;
3182
3183                                 case 1:
3184                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3185                                 break;
3186
3187                                 case 2:
3188                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3189                                 break;
3190
3191                                 case 3:
3192                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3193                                 break;
3194
3195                                 case 4:
3196                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3197                                 break;
3198
3199                                 case 5:
3200                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3201                                 break;
3202
3203                                 case 6:
3204                                 break;
3205
3206                                 case 7:
3207                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3208                                 break;
3209
3210                                 case 8:
3211                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3212                                 break;
3213
3214                                 case 9:
3215                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3216                                 break;
3217
3218                                 default:
3219                                 break;
3220
3221                         }
3222                 }
3223                 ndr->flags = _flags_save_UNION;
3224         }
3225         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3226         return NDR_ERR_SUCCESS;
3227 }
3228
3229 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3230 {
3231         int level;
3232         {
3233                 uint32_t _flags_save_UNION = ndr->flags;
3234                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
3235                 level = ndr_print_get_switch_value(ndr, r);
3236                 ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3237                 switch (level) {
3238                         case 0:
3239                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3240                         break;
3241
3242                         case 1:
3243                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3244                         break;
3245
3246                         case 2:
3247                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3248                         break;
3249
3250                         case 3:
3251                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3252                         break;
3253
3254                         case 4:
3255                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3256                         break;
3257
3258                         case 5:
3259                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3260                         break;
3261
3262                         case 6:
3263                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3264                         break;
3265
3266                         case 7:
3267                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3268                         break;
3269
3270                         case 8:
3271                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3272                         break;
3273
3274                         case 9:
3275                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3276                         break;
3277
3278                         default:
3279                         break;
3280
3281                 }
3282                 ndr->flags = _flags_save_UNION;
3283         }
3284 }
3285
3286 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3287 {
3288         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
3289         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3290 }
3291
3292 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3293 {
3294         if (ndr_flags & NDR_SCALARS) {
3295                 NDR_CHECK(ndr_push_align(ndr, 5));
3296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3298                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3299         }
3300         if (ndr_flags & NDR_BUFFERS) {
3301                 if (r->devmode) {
3302                         {
3303                                 struct ndr_push *_ndr_devmode;
3304                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3305                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3306                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3307                         }
3308                 }
3309         }
3310         return NDR_ERR_SUCCESS;
3311 }
3312
3313 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3314 {
3315         uint32_t _ptr_devmode;
3316         TALLOC_CTX *_mem_save_devmode_0;
3317         if (ndr_flags & NDR_SCALARS) {
3318                 NDR_CHECK(ndr_pull_align(ndr, 5));
3319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3321                 if (_ptr_devmode) {
3322                         NDR_PULL_ALLOC(ndr, r->devmode);
3323                 } else {
3324                         r->devmode = NULL;
3325                 }
3326                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3327         }
3328         if (ndr_flags & NDR_BUFFERS) {
3329                 if (r->devmode) {
3330                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3331                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3332                         {
3333                                 struct ndr_pull *_ndr_devmode;
3334                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3335                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3336                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3337                         }
3338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3339                 }
3340         }
3341         return NDR_ERR_SUCCESS;
3342 }
3343
3344 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3345 {
3346         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3347         ndr->depth++;
3348         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);
3349         ndr_print_ptr(ndr, "devmode", r->devmode);
3350         ndr->depth++;
3351         if (r->devmode) {
3352                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3353         }
3354         ndr->depth--;
3355         ndr->depth--;
3356 }
3357
3358 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3359 {
3360         if (ndr_flags & NDR_SCALARS) {
3361                 NDR_CHECK(ndr_push_align(ndr, 5));
3362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3363                 {
3364                         uint32_t _flags_save_string = ndr->flags;
3365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3366                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3367                         ndr->flags = _flags_save_string;
3368                 }
3369                 {
3370                         uint32_t _flags_save_string = ndr->flags;
3371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3372                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3373                         ndr->flags = _flags_save_string;
3374                 }
3375                 {
3376                         uint32_t _flags_save_string = ndr->flags;
3377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3378                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3379                         ndr->flags = _flags_save_string;
3380                 }
3381                 {
3382                         uint32_t _flags_save_string = ndr->flags;
3383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3384                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3385                         ndr->flags = _flags_save_string;
3386                 }
3387                 {
3388                         uint32_t _flags_save_string = ndr->flags;
3389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3390                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3391                         ndr->flags = _flags_save_string;
3392                 }
3393                 {
3394                         uint32_t _flags_save_string = ndr->flags;
3395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3396                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3397                         ndr->flags = _flags_save_string;
3398                 }
3399                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3404                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3405                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3406         }
3407         if (ndr_flags & NDR_BUFFERS) {
3408                 {
3409                         uint32_t _flags_save_string = ndr->flags;
3410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3411                         if (r->printer_name) {
3412                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3413                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3414                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3415                         }
3416                         ndr->flags = _flags_save_string;
3417                 }
3418                 {
3419                         uint32_t _flags_save_string = ndr->flags;
3420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3421                         if (r->server_name) {
3422                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3423                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3424                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3425                         }
3426                         ndr->flags = _flags_save_string;
3427                 }
3428                 {
3429                         uint32_t _flags_save_string = ndr->flags;
3430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3431                         if (r->user_name) {
3432                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3433                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3434                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
3435                         }
3436                         ndr->flags = _flags_save_string;
3437                 }
3438                 {
3439                         uint32_t _flags_save_string = ndr->flags;
3440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3441                         if (r->document_name) {
3442                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3443                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3444                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3445                         }
3446                         ndr->flags = _flags_save_string;
3447                 }
3448                 {
3449                         uint32_t _flags_save_string = ndr->flags;
3450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3451                         if (r->data_type) {
3452                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3453                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3454                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
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->text_status) {
3462                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3463                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3464                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3465                         }
3466                         ndr->flags = _flags_save_string;
3467                 }
3468         }
3469         return NDR_ERR_SUCCESS;
3470 }
3471
3472 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3473 {
3474         uint32_t _ptr_printer_name;
3475         TALLOC_CTX *_mem_save_printer_name_0;
3476         uint32_t _ptr_server_name;
3477         TALLOC_CTX *_mem_save_server_name_0;
3478         uint32_t _ptr_user_name;
3479         TALLOC_CTX *_mem_save_user_name_0;
3480         uint32_t _ptr_document_name;
3481         TALLOC_CTX *_mem_save_document_name_0;
3482         uint32_t _ptr_data_type;
3483         TALLOC_CTX *_mem_save_data_type_0;
3484         uint32_t _ptr_text_status;
3485         TALLOC_CTX *_mem_save_text_status_0;
3486         if (ndr_flags & NDR_SCALARS) {
3487                 NDR_CHECK(ndr_pull_align(ndr, 5));
3488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3489                 {
3490                         uint32_t _flags_save_string = ndr->flags;
3491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3492                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3493                         if (_ptr_printer_name) {
3494                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3495                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3496                         } else {
3497                                 r->printer_name = NULL;
3498                         }
3499                         ndr->flags = _flags_save_string;
3500                 }
3501                 {
3502                         uint32_t _flags_save_string = ndr->flags;
3503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3504                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3505                         if (_ptr_server_name) {
3506                                 NDR_PULL_ALLOC(ndr, r->server_name);
3507                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3508                         } else {
3509                                 r->server_name = NULL;
3510                         }
3511                         ndr->flags = _flags_save_string;
3512                 }
3513                 {
3514                         uint32_t _flags_save_string = ndr->flags;
3515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3516                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3517                         if (_ptr_user_name) {
3518                                 NDR_PULL_ALLOC(ndr, r->user_name);
3519                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3520                         } else {
3521                                 r->user_name = NULL;
3522                         }
3523                         ndr->flags = _flags_save_string;
3524                 }
3525                 {
3526                         uint32_t _flags_save_string = ndr->flags;
3527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3529                         if (_ptr_document_name) {
3530                                 NDR_PULL_ALLOC(ndr, r->document_name);
3531                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3532                         } else {
3533                                 r->document_name = NULL;
3534                         }
3535                         ndr->flags = _flags_save_string;
3536                 }
3537                 {
3538                         uint32_t _flags_save_string = ndr->flags;
3539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3540                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3541                         if (_ptr_data_type) {
3542                                 NDR_PULL_ALLOC(ndr, r->data_type);
3543                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3544                         } else {
3545                                 r->data_type = NULL;
3546                         }
3547                         ndr->flags = _flags_save_string;
3548                 }
3549                 {
3550                         uint32_t _flags_save_string = ndr->flags;
3551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3552                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3553                         if (_ptr_text_status) {
3554                                 NDR_PULL_ALLOC(ndr, r->text_status);
3555                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3556                         } else {
3557                                 r->text_status = NULL;
3558                         }
3559                         ndr->flags = _flags_save_string;
3560                 }
3561                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3563                 if (r->priority > 99) {
3564                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3565                 }
3566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3569                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3570                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3571         }
3572         if (ndr_flags & NDR_BUFFERS) {
3573                 {
3574                         uint32_t _flags_save_string = ndr->flags;
3575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3576                         if (r->printer_name) {
3577                                 uint32_t _relative_save_offset;
3578                                 _relative_save_offset = ndr->offset;
3579                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3580                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3581                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3582                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3583                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3584                                 if (ndr->offset > ndr->relative_highest_offset) {
3585                                         ndr->relative_highest_offset = ndr->offset;
3586                                 }
3587                                 ndr->offset = _relative_save_offset;
3588                         }
3589                         ndr->flags = _flags_save_string;
3590                 }
3591                 {
3592                         uint32_t _flags_save_string = ndr->flags;
3593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3594                         if (r->server_name) {
3595                                 uint32_t _relative_save_offset;
3596                                 _relative_save_offset = ndr->offset;
3597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3598                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3599                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3602                                 if (ndr->offset > ndr->relative_highest_offset) {
3603                                         ndr->relative_highest_offset = ndr->offset;
3604                                 }
3605                                 ndr->offset = _relative_save_offset;
3606                         }
3607                         ndr->flags = _flags_save_string;
3608                 }
3609                 {
3610                         uint32_t _flags_save_string = ndr->flags;
3611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3612                         if (r->user_name) {
3613                                 uint32_t _relative_save_offset;
3614                                 _relative_save_offset = ndr->offset;
3615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3616                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3617                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3620                                 if (ndr->offset > ndr->relative_highest_offset) {
3621                                         ndr->relative_highest_offset = ndr->offset;
3622                                 }
3623                                 ndr->offset = _relative_save_offset;
3624                         }
3625                         ndr->flags = _flags_save_string;
3626                 }
3627                 {
3628                         uint32_t _flags_save_string = ndr->flags;
3629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3630                         if (r->document_name) {
3631                                 uint32_t _relative_save_offset;
3632                                 _relative_save_offset = ndr->offset;
3633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3634                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3635                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3636                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3637                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3638                                 if (ndr->offset > ndr->relative_highest_offset) {
3639                                         ndr->relative_highest_offset = ndr->offset;
3640                                 }
3641                                 ndr->offset = _relative_save_offset;
3642                         }
3643                         ndr->flags = _flags_save_string;
3644                 }
3645                 {
3646                         uint32_t _flags_save_string = ndr->flags;
3647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3648                         if (r->data_type) {
3649                                 uint32_t _relative_save_offset;
3650                                 _relative_save_offset = ndr->offset;
3651                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3652                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3653                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3654                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3655                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3656                                 if (ndr->offset > ndr->relative_highest_offset) {
3657                                         ndr->relative_highest_offset = ndr->offset;
3658                                 }
3659                                 ndr->offset = _relative_save_offset;
3660                         }
3661                         ndr->flags = _flags_save_string;
3662                 }
3663                 {
3664                         uint32_t _flags_save_string = ndr->flags;
3665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3666                         if (r->text_status) {
3667                                 uint32_t _relative_save_offset;
3668                                 _relative_save_offset = ndr->offset;
3669                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3670                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3671                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3672                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3673                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3674                                 if (ndr->offset > ndr->relative_highest_offset) {
3675                                         ndr->relative_highest_offset = ndr->offset;
3676                                 }
3677                                 ndr->offset = _relative_save_offset;
3678                         }
3679                         ndr->flags = _flags_save_string;
3680                 }
3681         }
3682         return NDR_ERR_SUCCESS;
3683 }
3684
3685 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3686 {
3687         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3688         ndr->depth++;
3689         ndr_print_uint32(ndr, "job_id", r->job_id);
3690         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3691         ndr->depth++;
3692         if (r->printer_name) {
3693                 ndr_print_string(ndr, "printer_name", r->printer_name);
3694         }
3695         ndr->depth--;
3696         ndr_print_ptr(ndr, "server_name", r->server_name);
3697         ndr->depth++;
3698         if (r->server_name) {
3699                 ndr_print_string(ndr, "server_name", r->server_name);
3700         }
3701         ndr->depth--;
3702         ndr_print_ptr(ndr, "user_name", r->user_name);
3703         ndr->depth++;
3704         if (r->user_name) {
3705                 ndr_print_string(ndr, "user_name", r->user_name);
3706         }
3707         ndr->depth--;
3708         ndr_print_ptr(ndr, "document_name", r->document_name);
3709         ndr->depth++;
3710         if (r->document_name) {
3711                 ndr_print_string(ndr, "document_name", r->document_name);
3712         }
3713         ndr->depth--;
3714         ndr_print_ptr(ndr, "data_type", r->data_type);
3715         ndr->depth++;
3716         if (r->data_type) {
3717                 ndr_print_string(ndr, "data_type", r->data_type);
3718         }
3719         ndr->depth--;
3720         ndr_print_ptr(ndr, "text_status", r->text_status);
3721         ndr->depth++;
3722         if (r->text_status) {
3723                 ndr_print_string(ndr, "text_status", r->text_status);
3724         }
3725         ndr->depth--;
3726         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3727         ndr_print_uint32(ndr, "priority", r->priority);
3728         ndr_print_uint32(ndr, "position", r->position);
3729         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3730         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3731         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3732         ndr->depth--;
3733 }
3734
3735 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3736 {
3737         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3738 }
3739
3740 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3741 {
3742         if (ndr_flags & NDR_SCALARS) {
3743                 NDR_CHECK(ndr_push_align(ndr, 5));
3744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3745                 {
3746                         uint32_t _flags_save_string = ndr->flags;
3747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3749                         ndr->flags = _flags_save_string;
3750                 }
3751                 {
3752                         uint32_t _flags_save_string = ndr->flags;
3753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3755                         ndr->flags = _flags_save_string;
3756                 }
3757                 {
3758                         uint32_t _flags_save_string = ndr->flags;
3759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3760                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3761                         ndr->flags = _flags_save_string;
3762                 }
3763                 {
3764                         uint32_t _flags_save_string = ndr->flags;
3765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3767                         ndr->flags = _flags_save_string;
3768                 }
3769                 {
3770                         uint32_t _flags_save_string = ndr->flags;
3771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3772                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3773                         ndr->flags = _flags_save_string;
3774                 }
3775                 {
3776                         uint32_t _flags_save_string = ndr->flags;
3777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3778                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3779                         ndr->flags = _flags_save_string;
3780                 }
3781                 {
3782                         uint32_t _flags_save_string = ndr->flags;
3783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3784                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3785                         ndr->flags = _flags_save_string;
3786                 }
3787                 {
3788                         uint32_t _flags_save_string = ndr->flags;
3789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3790                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3791                         ndr->flags = _flags_save_string;
3792                 }
3793                 {
3794                         uint32_t _flags_save_string = ndr->flags;
3795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3796                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3797                         ndr->flags = _flags_save_string;
3798                 }
3799                 {
3800                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3802                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3803                         ndr->flags = _flags_save_spoolss_DeviceMode;
3804                 }
3805                 {
3806                         uint32_t _flags_save_string = ndr->flags;
3807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3808                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3809                         ndr->flags = _flags_save_string;
3810                 }
3811                 {
3812                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3814                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3815                         ndr->flags = _flags_save_spoolss_security_descriptor;
3816                 }
3817                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3822                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3824                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3827                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3828         }
3829         if (ndr_flags & NDR_BUFFERS) {
3830                 {
3831                         uint32_t _flags_save_string = ndr->flags;
3832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3833                         if (r->printer_name) {
3834                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
3835                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3836                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
3837                         }
3838                         ndr->flags = _flags_save_string;
3839                 }
3840                 {
3841                         uint32_t _flags_save_string = ndr->flags;
3842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3843                         if (r->server_name) {
3844                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
3845                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3846                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
3847                         }
3848                         ndr->flags = _flags_save_string;
3849                 }
3850                 {
3851                         uint32_t _flags_save_string = ndr->flags;
3852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3853                         if (r->user_name) {
3854                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
3855                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3856                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
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                         if (r->document_name) {
3864                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
3865                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3866                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
3867                         }
3868                         ndr->flags = _flags_save_string;
3869                 }
3870                 {
3871                         uint32_t _flags_save_string = ndr->flags;
3872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3873                         if (r->notify_name) {
3874                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
3875                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3876                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 {
3881                         uint32_t _flags_save_string = ndr->flags;
3882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3883                         if (r->data_type) {
3884                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
3885                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3886                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
3887                         }
3888                         ndr->flags = _flags_save_string;
3889                 }
3890                 {
3891                         uint32_t _flags_save_string = ndr->flags;
3892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3893                         if (r->print_processor) {
3894                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
3895                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3896                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
3897                         }
3898                         ndr->flags = _flags_save_string;
3899                 }
3900                 {
3901                         uint32_t _flags_save_string = ndr->flags;
3902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3903                         if (r->parameters) {
3904                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
3905                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3906                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
3907                         }
3908                         ndr->flags = _flags_save_string;
3909                 }
3910                 {
3911                         uint32_t _flags_save_string = ndr->flags;
3912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3913                         if (r->driver_name) {
3914                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
3915                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3916                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
3917                         }
3918                         ndr->flags = _flags_save_string;
3919                 }
3920                 {
3921                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
3922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3923                         if (r->devmode) {
3924                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
3925                                 {
3926                                         struct ndr_push *_ndr_devmode;
3927                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
3928                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3929                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
3930                                 }
3931                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
3932                         }
3933                         ndr->flags = _flags_save_spoolss_DeviceMode;
3934                 }
3935                 {
3936                         uint32_t _flags_save_string = ndr->flags;
3937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3938                         if (r->text_status) {
3939                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
3940                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3941                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
3942                         }
3943                         ndr->flags = _flags_save_string;
3944                 }
3945                 {
3946                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
3947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
3948                         if (r->secdesc) {
3949                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
3950                                 {
3951                                         struct ndr_push *_ndr_secdesc;
3952                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
3953                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3954                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
3955                                 }
3956                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
3957                         }
3958                         ndr->flags = _flags_save_spoolss_security_descriptor;
3959                 }
3960         }
3961         return NDR_ERR_SUCCESS;
3962 }
3963
3964 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3965 {
3966         uint32_t _ptr_printer_name;
3967         TALLOC_CTX *_mem_save_printer_name_0;
3968         uint32_t _ptr_server_name;
3969         TALLOC_CTX *_mem_save_server_name_0;
3970         uint32_t _ptr_user_name;
3971         TALLOC_CTX *_mem_save_user_name_0;
3972         uint32_t _ptr_document_name;
3973         TALLOC_CTX *_mem_save_document_name_0;
3974         uint32_t _ptr_notify_name;
3975         TALLOC_CTX *_mem_save_notify_name_0;
3976         uint32_t _ptr_data_type;
3977         TALLOC_CTX *_mem_save_data_type_0;
3978         uint32_t _ptr_print_processor;
3979         TALLOC_CTX *_mem_save_print_processor_0;
3980         uint32_t _ptr_parameters;
3981         TALLOC_CTX *_mem_save_parameters_0;
3982         uint32_t _ptr_driver_name;
3983         TALLOC_CTX *_mem_save_driver_name_0;
3984         uint32_t _ptr_devmode;
3985         TALLOC_CTX *_mem_save_devmode_0;
3986         uint32_t _ptr_text_status;
3987         TALLOC_CTX *_mem_save_text_status_0;
3988         uint32_t _ptr_secdesc;
3989         TALLOC_CTX *_mem_save_secdesc_0;
3990         if (ndr_flags & NDR_SCALARS) {
3991                 NDR_CHECK(ndr_pull_align(ndr, 5));
3992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3993                 {
3994                         uint32_t _flags_save_string = ndr->flags;
3995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3996                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3997                         if (_ptr_printer_name) {
3998                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3999                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4000                         } else {
4001                                 r->printer_name = NULL;
4002                         }
4003                         ndr->flags = _flags_save_string;
4004                 }
4005                 {
4006                         uint32_t _flags_save_string = ndr->flags;
4007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4008                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4009                         if (_ptr_server_name) {
4010                                 NDR_PULL_ALLOC(ndr, r->server_name);
4011                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4012                         } else {
4013                                 r->server_name = NULL;
4014                         }
4015                         ndr->flags = _flags_save_string;
4016                 }
4017                 {
4018                         uint32_t _flags_save_string = ndr->flags;
4019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4020                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4021                         if (_ptr_user_name) {
4022                                 NDR_PULL_ALLOC(ndr, r->user_name);
4023                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4024                         } else {
4025                                 r->user_name = NULL;
4026                         }
4027                         ndr->flags = _flags_save_string;
4028                 }
4029                 {
4030                         uint32_t _flags_save_string = ndr->flags;
4031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4032                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4033                         if (_ptr_document_name) {
4034                                 NDR_PULL_ALLOC(ndr, r->document_name);
4035                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4036                         } else {
4037                                 r->document_name = NULL;
4038                         }
4039                         ndr->flags = _flags_save_string;
4040                 }
4041                 {
4042                         uint32_t _flags_save_string = ndr->flags;
4043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4045                         if (_ptr_notify_name) {
4046                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4048                         } else {
4049                                 r->notify_name = NULL;
4050                         }
4051                         ndr->flags = _flags_save_string;
4052                 }
4053                 {
4054                         uint32_t _flags_save_string = ndr->flags;
4055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4057                         if (_ptr_data_type) {
4058                                 NDR_PULL_ALLOC(ndr, r->data_type);
4059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4060                         } else {
4061                                 r->data_type = NULL;
4062                         }
4063                         ndr->flags = _flags_save_string;
4064                 }
4065                 {
4066                         uint32_t _flags_save_string = ndr->flags;
4067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4068                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4069                         if (_ptr_print_processor) {
4070                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4071                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4072                         } else {
4073                                 r->print_processor = NULL;
4074                         }
4075                         ndr->flags = _flags_save_string;
4076                 }
4077                 {
4078                         uint32_t _flags_save_string = ndr->flags;
4079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4080                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4081                         if (_ptr_parameters) {
4082                                 NDR_PULL_ALLOC(ndr, r->parameters);
4083                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4084                         } else {
4085                                 r->parameters = NULL;
4086                         }
4087                         ndr->flags = _flags_save_string;
4088                 }
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4092                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4093                         if (_ptr_driver_name) {
4094                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4095                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4096                         } else {
4097                                 r->driver_name = NULL;
4098                         }
4099                         ndr->flags = _flags_save_string;
4100                 }
4101                 {
4102                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4104                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4105                         if (_ptr_devmode) {
4106                                 NDR_PULL_ALLOC(ndr, r->devmode);
4107                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4108                         } else {
4109                                 r->devmode = NULL;
4110                         }
4111                         ndr->flags = _flags_save_spoolss_DeviceMode;
4112                 }
4113                 {
4114                         uint32_t _flags_save_string = ndr->flags;
4115                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4116                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4117                         if (_ptr_text_status) {
4118                                 NDR_PULL_ALLOC(ndr, r->text_status);
4119                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4120                         } else {
4121                                 r->text_status = NULL;
4122                         }
4123                         ndr->flags = _flags_save_string;
4124                 }
4125                 {
4126                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4128                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4129                         if (_ptr_secdesc) {
4130                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4131                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4132                         } else {
4133                                 r->secdesc = NULL;
4134                         }
4135                         ndr->flags = _flags_save_spoolss_security_descriptor;
4136                 }
4137                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4139                 if (r->priority > 99) {
4140                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4141                 }
4142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4147                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4150                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4151         }
4152         if (ndr_flags & NDR_BUFFERS) {
4153                 {
4154                         uint32_t _flags_save_string = ndr->flags;
4155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4156                         if (r->printer_name) {
4157                                 uint32_t _relative_save_offset;
4158                                 _relative_save_offset = ndr->offset;
4159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4160                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4161                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4162                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4164                                 if (ndr->offset > ndr->relative_highest_offset) {
4165                                         ndr->relative_highest_offset = ndr->offset;
4166                                 }
4167                                 ndr->offset = _relative_save_offset;
4168                         }
4169                         ndr->flags = _flags_save_string;
4170                 }
4171                 {
4172                         uint32_t _flags_save_string = ndr->flags;
4173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4174                         if (r->server_name) {
4175                                 uint32_t _relative_save_offset;
4176                                 _relative_save_offset = ndr->offset;
4177                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4178                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4179                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4180                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4181                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4182                                 if (ndr->offset > ndr->relative_highest_offset) {
4183                                         ndr->relative_highest_offset = ndr->offset;
4184                                 }
4185                                 ndr->offset = _relative_save_offset;
4186                         }
4187                         ndr->flags = _flags_save_string;
4188                 }
4189                 {
4190                         uint32_t _flags_save_string = ndr->flags;
4191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4192                         if (r->user_name) {
4193                                 uint32_t _relative_save_offset;
4194                                 _relative_save_offset = ndr->offset;
4195                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4196                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4197                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4198                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4199                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4200                                 if (ndr->offset > ndr->relative_highest_offset) {
4201                                         ndr->relative_highest_offset = ndr->offset;
4202                                 }
4203                                 ndr->offset = _relative_save_offset;
4204                         }
4205                         ndr->flags = _flags_save_string;
4206                 }
4207                 {
4208                         uint32_t _flags_save_string = ndr->flags;
4209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4210                         if (r->document_name) {
4211                                 uint32_t _relative_save_offset;
4212                                 _relative_save_offset = ndr->offset;
4213                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4214                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4215                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4216                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4217                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4218                                 if (ndr->offset > ndr->relative_highest_offset) {
4219                                         ndr->relative_highest_offset = ndr->offset;
4220                                 }
4221                                 ndr->offset = _relative_save_offset;
4222                         }
4223                         ndr->flags = _flags_save_string;
4224                 }
4225                 {
4226                         uint32_t _flags_save_string = ndr->flags;
4227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4228                         if (r->notify_name) {
4229                                 uint32_t _relative_save_offset;
4230                                 _relative_save_offset = ndr->offset;
4231                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4232                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4233                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4234                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4235                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4236                                 if (ndr->offset > ndr->relative_highest_offset) {
4237                                         ndr->relative_highest_offset = ndr->offset;
4238                                 }
4239                                 ndr->offset = _relative_save_offset;
4240                         }
4241                         ndr->flags = _flags_save_string;
4242                 }
4243                 {
4244                         uint32_t _flags_save_string = ndr->flags;
4245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4246                         if (r->data_type) {
4247                                 uint32_t _relative_save_offset;
4248                                 _relative_save_offset = ndr->offset;
4249                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4250                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4251                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4252                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4253                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4254                                 if (ndr->offset > ndr->relative_highest_offset) {
4255                                         ndr->relative_highest_offset = ndr->offset;
4256                                 }
4257                                 ndr->offset = _relative_save_offset;
4258                         }
4259                         ndr->flags = _flags_save_string;
4260                 }
4261                 {
4262                         uint32_t _flags_save_string = ndr->flags;
4263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4264                         if (r->print_processor) {
4265                                 uint32_t _relative_save_offset;
4266                                 _relative_save_offset = ndr->offset;
4267                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4268                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4269                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4270                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4271                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4272                                 if (ndr->offset > ndr->relative_highest_offset) {
4273                                         ndr->relative_highest_offset = ndr->offset;
4274                                 }
4275                                 ndr->offset = _relative_save_offset;
4276                         }
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                         if (r->parameters) {
4283                                 uint32_t _relative_save_offset;
4284                                 _relative_save_offset = ndr->offset;
4285                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4286                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4287                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4288                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4289                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4290                                 if (ndr->offset > ndr->relative_highest_offset) {
4291                                         ndr->relative_highest_offset = ndr->offset;
4292                                 }
4293                                 ndr->offset = _relative_save_offset;
4294                         }
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                         if (r->driver_name) {
4301                                 uint32_t _relative_save_offset;
4302                                 _relative_save_offset = ndr->offset;
4303                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4304                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4305                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4306                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4307                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4308                                 if (ndr->offset > ndr->relative_highest_offset) {
4309                                         ndr->relative_highest_offset = ndr->offset;
4310                                 }
4311                                 ndr->offset = _relative_save_offset;
4312                         }
4313                         ndr->flags = _flags_save_string;
4314                 }
4315                 {
4316                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4318                         if (r->devmode) {
4319                                 uint32_t _relative_save_offset;
4320                                 _relative_save_offset = ndr->offset;
4321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4322                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4323                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4324                                 {
4325                                         struct ndr_pull *_ndr_devmode;
4326                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4327                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4328                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
4329                                 }
4330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4331                                 if (ndr->offset > ndr->relative_highest_offset) {
4332                                         ndr->relative_highest_offset = ndr->offset;
4333                                 }
4334                                 ndr->offset = _relative_save_offset;
4335                         }
4336                         ndr->flags = _flags_save_spoolss_DeviceMode;
4337                 }
4338                 {
4339                         uint32_t _flags_save_string = ndr->flags;
4340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4341                         if (r->text_status) {
4342                                 uint32_t _relative_save_offset;
4343                                 _relative_save_offset = ndr->offset;
4344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4345                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4346                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4349                                 if (ndr->offset > ndr->relative_highest_offset) {
4350                                         ndr->relative_highest_offset = ndr->offset;
4351                                 }
4352                                 ndr->offset = _relative_save_offset;
4353                         }
4354                         ndr->flags = _flags_save_string;
4355                 }
4356                 {
4357                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4359                         if (r->secdesc) {
4360                                 uint32_t _relative_save_offset;
4361                                 _relative_save_offset = ndr->offset;
4362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4363                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4364                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4365                                 {
4366                                         struct ndr_pull *_ndr_secdesc;
4367                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4368                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4369                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4370                                 }
4371                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4372                                 if (ndr->offset > ndr->relative_highest_offset) {
4373                                         ndr->relative_highest_offset = ndr->offset;
4374                                 }
4375                                 ndr->offset = _relative_save_offset;
4376                         }
4377                         ndr->flags = _flags_save_spoolss_security_descriptor;
4378                 }
4379         }
4380         return NDR_ERR_SUCCESS;
4381 }
4382
4383 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4384 {
4385         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4386         ndr->depth++;
4387         ndr_print_uint32(ndr, "job_id", r->job_id);
4388         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4389         ndr->depth++;
4390         if (r->printer_name) {
4391                 ndr_print_string(ndr, "printer_name", r->printer_name);
4392         }
4393         ndr->depth--;
4394         ndr_print_ptr(ndr, "server_name", r->server_name);
4395         ndr->depth++;
4396         if (r->server_name) {
4397                 ndr_print_string(ndr, "server_name", r->server_name);
4398         }
4399         ndr->depth--;
4400         ndr_print_ptr(ndr, "user_name", r->user_name);
4401         ndr->depth++;
4402         if (r->user_name) {
4403                 ndr_print_string(ndr, "user_name", r->user_name);
4404         }
4405         ndr->depth--;
4406         ndr_print_ptr(ndr, "document_name", r->document_name);
4407         ndr->depth++;
4408         if (r->document_name) {
4409                 ndr_print_string(ndr, "document_name", r->document_name);
4410         }
4411         ndr->depth--;
4412         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4413         ndr->depth++;
4414         if (r->notify_name) {
4415                 ndr_print_string(ndr, "notify_name", r->notify_name);
4416         }
4417         ndr->depth--;
4418         ndr_print_ptr(ndr, "data_type", r->data_type);
4419         ndr->depth++;
4420         if (r->data_type) {
4421                 ndr_print_string(ndr, "data_type", r->data_type);
4422         }
4423         ndr->depth--;
4424         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4425         ndr->depth++;
4426         if (r->print_processor) {
4427                 ndr_print_string(ndr, "print_processor", r->print_processor);
4428         }
4429         ndr->depth--;
4430         ndr_print_ptr(ndr, "parameters", r->parameters);
4431         ndr->depth++;
4432         if (r->parameters) {
4433                 ndr_print_string(ndr, "parameters", r->parameters);
4434         }
4435         ndr->depth--;
4436         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4437         ndr->depth++;
4438         if (r->driver_name) {
4439                 ndr_print_string(ndr, "driver_name", r->driver_name);
4440         }
4441         ndr->depth--;
4442         ndr_print_ptr(ndr, "devmode", r->devmode);
4443         ndr->depth++;
4444         if (r->devmode) {
4445                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4446         }
4447         ndr->depth--;
4448         ndr_print_ptr(ndr, "text_status", r->text_status);
4449         ndr->depth++;
4450         if (r->text_status) {
4451                 ndr_print_string(ndr, "text_status", r->text_status);
4452         }
4453         ndr->depth--;
4454         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4455         ndr->depth++;
4456         if (r->secdesc) {
4457                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
4458         }
4459         ndr->depth--;
4460         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4461         ndr_print_uint32(ndr, "priority", r->priority);
4462         ndr_print_uint32(ndr, "position", r->position);
4463         ndr_print_uint32(ndr, "start_time", r->start_time);
4464         ndr_print_uint32(ndr, "until_time", r->until_time);
4465         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4466         ndr_print_uint32(ndr, "size", r->size);
4467         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4468         ndr_print_uint32(ndr, "time", r->time);
4469         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4470         ndr->depth--;
4471 }
4472
4473 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4474 {
4475         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4476 }
4477
4478 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4479 {
4480         if (ndr_flags & NDR_SCALARS) {
4481                 NDR_CHECK(ndr_push_align(ndr, 4));
4482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4485                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4486         }
4487         if (ndr_flags & NDR_BUFFERS) {
4488         }
4489         return NDR_ERR_SUCCESS;
4490 }
4491
4492 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4493 {
4494         if (ndr_flags & NDR_SCALARS) {
4495                 NDR_CHECK(ndr_pull_align(ndr, 4));
4496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4499                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4500         }
4501         if (ndr_flags & NDR_BUFFERS) {
4502         }
4503         return NDR_ERR_SUCCESS;
4504 }
4505
4506 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4507 {
4508         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4509         ndr->depth++;
4510         ndr_print_uint32(ndr, "job_id", r->job_id);
4511         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4512         ndr_print_uint32(ndr, "reserved", r->reserved);
4513         ndr->depth--;
4514 }
4515
4516 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4517 {
4518         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4519 }
4520
4521 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4522 {
4523         if (ndr_flags & NDR_SCALARS) {
4524                 NDR_CHECK(ndr_push_align(ndr, 5));
4525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4526                 {
4527                         uint32_t _flags_save_string = ndr->flags;
4528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4529                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4530                         ndr->flags = _flags_save_string;
4531                 }
4532                 {
4533                         uint32_t _flags_save_string = ndr->flags;
4534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4535                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4536                         ndr->flags = _flags_save_string;
4537                 }
4538                 {
4539                         uint32_t _flags_save_string = ndr->flags;
4540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4541                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4542                         ndr->flags = _flags_save_string;
4543                 }
4544                 {
4545                         uint32_t _flags_save_string = ndr->flags;
4546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4548                         ndr->flags = _flags_save_string;
4549                 }
4550                 {
4551                         uint32_t _flags_save_string = ndr->flags;
4552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4553                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4554                         ndr->flags = _flags_save_string;
4555                 }
4556                 {
4557                         uint32_t _flags_save_string = ndr->flags;
4558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4559                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4560                         ndr->flags = _flags_save_string;
4561                 }
4562                 {
4563                         uint32_t _flags_save_string = ndr->flags;
4564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4566                         ndr->flags = _flags_save_string;
4567                 }
4568                 {
4569                         uint32_t _flags_save_string = ndr->flags;
4570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4572                         ndr->flags = _flags_save_string;
4573                 }
4574                 {
4575                         uint32_t _flags_save_string = ndr->flags;
4576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4578                         ndr->flags = _flags_save_string;
4579                 }
4580                 {
4581                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4584                         ndr->flags = _flags_save_spoolss_DeviceMode;
4585                 }
4586                 {
4587                         uint32_t _flags_save_string = ndr->flags;
4588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4590                         ndr->flags = _flags_save_string;
4591                 }
4592                 {
4593                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4596                         ndr->flags = _flags_save_spoolss_security_descriptor;
4597                 }
4598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4605                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4609                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4610         }
4611         if (ndr_flags & NDR_BUFFERS) {
4612                 {
4613                         uint32_t _flags_save_string = ndr->flags;
4614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4615                         if (r->printer_name) {
4616                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->printer_name));
4617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4618                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->printer_name));
4619                         }
4620                         ndr->flags = _flags_save_string;
4621                 }
4622                 {
4623                         uint32_t _flags_save_string = ndr->flags;
4624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4625                         if (r->server_name) {
4626                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->server_name));
4627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4628                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->server_name));
4629                         }
4630                         ndr->flags = _flags_save_string;
4631                 }
4632                 {
4633                         uint32_t _flags_save_string = ndr->flags;
4634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4635                         if (r->user_name) {
4636                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->user_name));
4637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4638                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->user_name));
4639                         }
4640                         ndr->flags = _flags_save_string;
4641                 }
4642                 {
4643                         uint32_t _flags_save_string = ndr->flags;
4644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4645                         if (r->document_name) {
4646                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->document_name));
4647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4648                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->document_name));
4649                         }
4650                         ndr->flags = _flags_save_string;
4651                 }
4652                 {
4653                         uint32_t _flags_save_string = ndr->flags;
4654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4655                         if (r->notify_name) {
4656                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->notify_name));
4657                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4658                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->notify_name));
4659                         }
4660                         ndr->flags = _flags_save_string;
4661                 }
4662                 {
4663                         uint32_t _flags_save_string = ndr->flags;
4664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4665                         if (r->data_type) {
4666                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_type));
4667                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4668                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_type));
4669                         }
4670                         ndr->flags = _flags_save_string;
4671                 }
4672                 {
4673                         uint32_t _flags_save_string = ndr->flags;
4674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4675                         if (r->print_processor) {
4676                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
4677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4678                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
4679                         }
4680                         ndr->flags = _flags_save_string;
4681                 }
4682                 {
4683                         uint32_t _flags_save_string = ndr->flags;
4684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4685                         if (r->parameters) {
4686                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->parameters));
4687                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4688                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->parameters));
4689                         }
4690                         ndr->flags = _flags_save_string;
4691                 }
4692                 {
4693                         uint32_t _flags_save_string = ndr->flags;
4694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4695                         if (r->driver_name) {
4696                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
4697                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4698                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
4699                         }
4700                         ndr->flags = _flags_save_string;
4701                 }
4702                 {
4703                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4705                         if (r->devmode) {
4706                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->devmode));
4707                                 {
4708                                         struct ndr_push *_ndr_devmode;
4709                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4710                                         NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4711                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4712                                 }
4713                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->devmode));
4714                         }
4715                         ndr->flags = _flags_save_spoolss_DeviceMode;
4716                 }
4717                 {
4718                         uint32_t _flags_save_string = ndr->flags;
4719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4720                         if (r->text_status) {
4721                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->text_status));
4722                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4723                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->text_status));
4724                         }
4725                         ndr->flags = _flags_save_string;
4726                 }
4727                 {
4728                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4730                         if (r->secdesc) {
4731                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->secdesc));
4732                                 {
4733                                         struct ndr_push *_ndr_secdesc;
4734                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4735                                         NDR_CHECK(ndr_push_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4736                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4737                                 }
4738                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->secdesc));
4739                         }
4740                         ndr->flags = _flags_save_spoolss_security_descriptor;
4741                 }
4742         }
4743         return NDR_ERR_SUCCESS;
4744 }
4745
4746 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4747 {
4748         uint32_t _ptr_printer_name;
4749         TALLOC_CTX *_mem_save_printer_name_0;
4750         uint32_t _ptr_server_name;
4751         TALLOC_CTX *_mem_save_server_name_0;
4752         uint32_t _ptr_user_name;
4753         TALLOC_CTX *_mem_save_user_name_0;
4754         uint32_t _ptr_document_name;
4755         TALLOC_CTX *_mem_save_document_name_0;
4756         uint32_t _ptr_notify_name;
4757         TALLOC_CTX *_mem_save_notify_name_0;
4758         uint32_t _ptr_data_type;
4759         TALLOC_CTX *_mem_save_data_type_0;
4760         uint32_t _ptr_print_processor;
4761         TALLOC_CTX *_mem_save_print_processor_0;
4762         uint32_t _ptr_parameters;
4763         TALLOC_CTX *_mem_save_parameters_0;
4764         uint32_t _ptr_driver_name;
4765         TALLOC_CTX *_mem_save_driver_name_0;
4766         uint32_t _ptr_devmode;
4767         TALLOC_CTX *_mem_save_devmode_0;
4768         uint32_t _ptr_text_status;
4769         TALLOC_CTX *_mem_save_text_status_0;
4770         uint32_t _ptr_secdesc;
4771         TALLOC_CTX *_mem_save_secdesc_0;
4772         if (ndr_flags & NDR_SCALARS) {
4773                 NDR_CHECK(ndr_pull_align(ndr, 5));
4774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4775                 {
4776                         uint32_t _flags_save_string = ndr->flags;
4777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4779                         if (_ptr_printer_name) {
4780                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4782                         } else {
4783                                 r->printer_name = NULL;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 {
4788                         uint32_t _flags_save_string = ndr->flags;
4789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4791                         if (_ptr_server_name) {
4792                                 NDR_PULL_ALLOC(ndr, r->server_name);
4793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4794                         } else {
4795                                 r->server_name = NULL;
4796                         }
4797                         ndr->flags = _flags_save_string;
4798                 }
4799                 {
4800                         uint32_t _flags_save_string = ndr->flags;
4801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4802                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4803                         if (_ptr_user_name) {
4804                                 NDR_PULL_ALLOC(ndr, r->user_name);
4805                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4806                         } else {
4807                                 r->user_name = NULL;
4808                         }
4809                         ndr->flags = _flags_save_string;
4810                 }
4811                 {
4812                         uint32_t _flags_save_string = ndr->flags;
4813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4815                         if (_ptr_document_name) {
4816                                 NDR_PULL_ALLOC(ndr, r->document_name);
4817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4818                         } else {
4819                                 r->document_name = NULL;
4820                         }
4821                         ndr->flags = _flags_save_string;
4822                 }
4823                 {
4824                         uint32_t _flags_save_string = ndr->flags;
4825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4826                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4827                         if (_ptr_notify_name) {
4828                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4829                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4830                         } else {
4831                                 r->notify_name = NULL;
4832                         }
4833                         ndr->flags = _flags_save_string;
4834                 }
4835                 {
4836                         uint32_t _flags_save_string = ndr->flags;
4837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4838                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4839                         if (_ptr_data_type) {
4840                                 NDR_PULL_ALLOC(ndr, r->data_type);
4841                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4842                         } else {
4843                                 r->data_type = NULL;
4844                         }
4845                         ndr->flags = _flags_save_string;
4846                 }
4847                 {
4848                         uint32_t _flags_save_string = ndr->flags;
4849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4850                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4851                         if (_ptr_print_processor) {
4852                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4853                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4854                         } else {
4855                                 r->print_processor = NULL;
4856                         }
4857                         ndr->flags = _flags_save_string;
4858                 }
4859                 {
4860                         uint32_t _flags_save_string = ndr->flags;
4861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4862                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4863                         if (_ptr_parameters) {
4864                                 NDR_PULL_ALLOC(ndr, r->parameters);
4865                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4866                         } else {
4867                                 r->parameters = NULL;
4868                         }
4869                         ndr->flags = _flags_save_string;
4870                 }
4871                 {
4872                         uint32_t _flags_save_string = ndr->flags;
4873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4875                         if (_ptr_driver_name) {
4876                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4878                         } else {
4879                                 r->driver_name = NULL;
4880                         }
4881                         ndr->flags = _flags_save_string;
4882                 }
4883                 {
4884                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
4885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4887                         if (_ptr_devmode) {
4888                                 NDR_PULL_ALLOC(ndr, r->devmode);
4889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4890                         } else {
4891                                 r->devmode = NULL;
4892                         }
4893                         ndr->flags = _flags_save_spoolss_DeviceMode;
4894                 }
4895                 {
4896                         uint32_t _flags_save_string = ndr->flags;
4897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4898                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4899                         if (_ptr_text_status) {
4900                                 NDR_PULL_ALLOC(ndr, r->text_status);
4901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4902                         } else {
4903                                 r->text_status = NULL;
4904                         }
4905                         ndr->flags = _flags_save_string;
4906                 }
4907                 {
4908                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
4909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
4910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4911                         if (_ptr_secdesc) {
4912                                 NDR_PULL_ALLOC(ndr, r->secdesc);
4913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4914                         } else {
4915                                 r->secdesc = NULL;
4916                         }
4917                         ndr->flags = _flags_save_spoolss_security_descriptor;
4918                 }
4919                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4921                 if (r->priority > 99) {
4922                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4923                 }
4924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4929                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4933                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4934         }
4935         if (ndr_flags & NDR_BUFFERS) {
4936                 {
4937                         uint32_t _flags_save_string = ndr->flags;
4938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4939                         if (r->printer_name) {
4940                                 uint32_t _relative_save_offset;
4941                                 _relative_save_offset = ndr->offset;
4942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4943                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4944                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4947                                 if (ndr->offset > ndr->relative_highest_offset) {
4948                                         ndr->relative_highest_offset = ndr->offset;
4949                                 }
4950                                 ndr->offset = _relative_save_offset;
4951                         }
4952                         ndr->flags = _flags_save_string;
4953                 }
4954                 {
4955                         uint32_t _flags_save_string = ndr->flags;
4956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4957                         if (r->server_name) {
4958                                 uint32_t _relative_save_offset;
4959                                 _relative_save_offset = ndr->offset;
4960                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4961                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4963                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4964                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4965                                 if (ndr->offset > ndr->relative_highest_offset) {
4966                                         ndr->relative_highest_offset = ndr->offset;
4967                                 }
4968                                 ndr->offset = _relative_save_offset;
4969                         }
4970                         ndr->flags = _flags_save_string;
4971                 }
4972                 {
4973                         uint32_t _flags_save_string = ndr->flags;
4974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4975                         if (r->user_name) {
4976                                 uint32_t _relative_save_offset;
4977                                 _relative_save_offset = ndr->offset;
4978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4979                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4980                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4981                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4983                                 if (ndr->offset > ndr->relative_highest_offset) {
4984                                         ndr->relative_highest_offset = ndr->offset;
4985                                 }
4986                                 ndr->offset = _relative_save_offset;
4987                         }
4988                         ndr->flags = _flags_save_string;
4989                 }
4990                 {
4991                         uint32_t _flags_save_string = ndr->flags;
4992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4993                         if (r->document_name) {
4994                                 uint32_t _relative_save_offset;
4995                                 _relative_save_offset = ndr->offset;
4996                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4997                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4998                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4999                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
5000                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5001                                 if (ndr->offset > ndr->relative_highest_offset) {
5002                                         ndr->relative_highest_offset = ndr->offset;
5003                                 }
5004                                 ndr->offset = _relative_save_offset;
5005                         }
5006                         ndr->flags = _flags_save_string;
5007                 }
5008                 {
5009                         uint32_t _flags_save_string = ndr->flags;
5010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5011                         if (r->notify_name) {
5012                                 uint32_t _relative_save_offset;
5013                                 _relative_save_offset = ndr->offset;
5014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
5015                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5016                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5017                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
5018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5019                                 if (ndr->offset > ndr->relative_highest_offset) {
5020                                         ndr->relative_highest_offset = ndr->offset;
5021                                 }
5022                                 ndr->offset = _relative_save_offset;
5023                         }
5024                         ndr->flags = _flags_save_string;
5025                 }
5026                 {
5027                         uint32_t _flags_save_string = ndr->flags;
5028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5029                         if (r->data_type) {
5030                                 uint32_t _relative_save_offset;
5031                                 _relative_save_offset = ndr->offset;
5032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
5033                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5034                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
5036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5037                                 if (ndr->offset > ndr->relative_highest_offset) {
5038                                         ndr->relative_highest_offset = ndr->offset;
5039                                 }
5040                                 ndr->offset = _relative_save_offset;
5041                         }
5042                         ndr->flags = _flags_save_string;
5043                 }
5044                 {
5045                         uint32_t _flags_save_string = ndr->flags;
5046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5047                         if (r->print_processor) {
5048                                 uint32_t _relative_save_offset;
5049                                 _relative_save_offset = ndr->offset;
5050                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
5051                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5052                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5053                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
5054                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5055                                 if (ndr->offset > ndr->relative_highest_offset) {
5056                                         ndr->relative_highest_offset = ndr->offset;
5057                                 }
5058                                 ndr->offset = _relative_save_offset;
5059                         }
5060                         ndr->flags = _flags_save_string;
5061                 }
5062                 {
5063                         uint32_t _flags_save_string = ndr->flags;
5064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5065                         if (r->parameters) {
5066                                 uint32_t _relative_save_offset;
5067                                 _relative_save_offset = ndr->offset;
5068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
5069                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5070                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
5072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5073                                 if (ndr->offset > ndr->relative_highest_offset) {
5074                                         ndr->relative_highest_offset = ndr->offset;
5075                                 }
5076                                 ndr->offset = _relative_save_offset;
5077                         }
5078                         ndr->flags = _flags_save_string;
5079                 }
5080                 {
5081                         uint32_t _flags_save_string = ndr->flags;
5082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5083                         if (r->driver_name) {
5084                                 uint32_t _relative_save_offset;
5085                                 _relative_save_offset = ndr->offset;
5086                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
5087                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5088                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5089                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
5090                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5091                                 if (ndr->offset > ndr->relative_highest_offset) {
5092                                         ndr->relative_highest_offset = ndr->offset;
5093                                 }
5094                                 ndr->offset = _relative_save_offset;
5095                         }
5096                         ndr->flags = _flags_save_string;
5097                 }
5098                 {
5099                         uint32_t _flags_save_spoolss_DeviceMode = ndr->flags;
5100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
5101                         if (r->devmode) {
5102                                 uint32_t _relative_save_offset;
5103                                 _relative_save_offset = ndr->offset;
5104                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
5105                                 _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
5106                                 NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
5107                                 {
5108                                         struct ndr_pull *_ndr_devmode;
5109                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
5110                                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
5111                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
5112                                 }
5113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
5114                                 if (ndr->offset > ndr->relative_highest_offset) {
5115                                         ndr->relative_highest_offset = ndr->offset;
5116                                 }
5117                                 ndr->offset = _relative_save_offset;
5118                         }
5119                         ndr->flags = _flags_save_spoolss_DeviceMode;
5120                 }
5121                 {
5122                         uint32_t _flags_save_string = ndr->flags;
5123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5124                         if (r->text_status) {
5125                                 uint32_t _relative_save_offset;
5126                                 _relative_save_offset = ndr->offset;
5127                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
5128                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5129                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5130                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
5131                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5132                                 if (ndr->offset > ndr->relative_highest_offset) {
5133                                         ndr->relative_highest_offset = ndr->offset;
5134                                 }
5135                                 ndr->offset = _relative_save_offset;
5136                         }
5137                         ndr->flags = _flags_save_string;
5138                 }
5139                 {
5140                         uint32_t _flags_save_spoolss_security_descriptor = ndr->flags;
5141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_ALIGN4);
5142                         if (r->secdesc) {
5143                                 uint32_t _relative_save_offset;
5144                                 _relative_save_offset = ndr->offset;
5145                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
5146                                 _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
5147                                 NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
5148                                 {
5149                                         struct ndr_pull *_ndr_secdesc;
5150                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
5151                                         NDR_CHECK(ndr_pull_spoolss_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
5152                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
5153                                 }
5154                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
5155                                 if (ndr->offset > ndr->relative_highest_offset) {
5156                                         ndr->relative_highest_offset = ndr->offset;
5157                                 }
5158                                 ndr->offset = _relative_save_offset;
5159                         }
5160                         ndr->flags = _flags_save_spoolss_security_descriptor;
5161                 }
5162         }
5163         return NDR_ERR_SUCCESS;
5164 }
5165
5166 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
5167 {
5168         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
5169         ndr->depth++;
5170         ndr_print_uint32(ndr, "job_id", r->job_id);
5171         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5172         ndr->depth++;
5173         if (r->printer_name) {
5174                 ndr_print_string(ndr, "printer_name", r->printer_name);
5175         }
5176         ndr->depth--;
5177         ndr_print_ptr(ndr, "server_name", r->server_name);
5178         ndr->depth++;
5179         if (r->server_name) {
5180                 ndr_print_string(ndr, "server_name", r->server_name);
5181         }
5182         ndr->depth--;
5183         ndr_print_ptr(ndr, "user_name", r->user_name);
5184         ndr->depth++;
5185         if (r->user_name) {
5186                 ndr_print_string(ndr, "user_name", r->user_name);
5187         }
5188         ndr->depth--;
5189         ndr_print_ptr(ndr, "document_name", r->document_name);
5190         ndr->depth++;
5191         if (r->document_name) {
5192                 ndr_print_string(ndr, "document_name", r->document_name);
5193         }
5194         ndr->depth--;
5195         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5196         ndr->depth++;
5197         if (r->notify_name) {
5198                 ndr_print_string(ndr, "notify_name", r->notify_name);
5199         }
5200         ndr->depth--;
5201         ndr_print_ptr(ndr, "data_type", r->data_type);
5202         ndr->depth++;
5203         if (r->data_type) {
5204                 ndr_print_string(ndr, "data_type", r->data_type);
5205         }
5206         ndr->depth--;
5207         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5208         ndr->depth++;
5209         if (r->print_processor) {
5210                 ndr_print_string(ndr, "print_processor", r->print_processor);
5211         }
5212         ndr->depth--;
5213         ndr_print_ptr(ndr, "parameters", r->parameters);
5214         ndr->depth++;
5215         if (r->parameters) {
5216                 ndr_print_string(ndr, "parameters", r->parameters);
5217         }
5218         ndr->depth--;
5219         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5220         ndr->depth++;
5221         if (r->driver_name) {
5222                 ndr_print_string(ndr, "driver_name", r->driver_name);
5223         }
5224         ndr->depth--;
5225         ndr_print_ptr(ndr, "devmode", r->devmode);
5226         ndr->depth++;
5227         if (r->devmode) {
5228                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
5229         }
5230         ndr->depth--;
5231         ndr_print_ptr(ndr, "text_status", r->text_status);
5232         ndr->depth++;
5233         if (r->text_status) {
5234                 ndr_print_string(ndr, "text_status", r->text_status);
5235         }
5236         ndr->depth--;
5237         ndr_print_ptr(ndr, "secdesc", r->secdesc);
5238         ndr->depth++;
5239         if (r->secdesc) {
5240                 ndr_print_spoolss_security_descriptor(ndr, "secdesc", r->secdesc);
5241         }
5242         ndr->depth--;
5243         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5244         ndr_print_uint32(ndr, "priority", r->priority);
5245         ndr_print_uint32(ndr, "position", r->position);
5246         ndr_print_uint32(ndr, "start_time", r->start_time);
5247         ndr_print_uint32(ndr, "until_time", r->until_time);
5248         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5249         ndr_print_uint32(ndr, "size", r->size);
5250         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5251         ndr_print_uint32(ndr, "time", r->time);
5252         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5253         ndr_print_uint32(ndr, "size_high", r->size_high);
5254         ndr->depth--;
5255 }
5256
5257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
5258 {
5259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
5260 }
5261
5262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
5263 {
5264         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
5265         {
5266                 uint32_t _flags_save_UNION = ndr->flags;
5267                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5268                 if (ndr_flags & NDR_SCALARS) {
5269                         int level = ndr_push_get_switch_value(ndr, r);
5270                         NDR_CHECK(ndr_push_union_align(ndr, 5));
5271                         switch (level) {
5272                                 case 1: {
5273                                         NDR_CHECK(ndr_push_align(ndr, 5));
5274                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5275                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5276                                 break; }
5277
5278                                 case 2: {
5279                                         NDR_CHECK(ndr_push_align(ndr, 5));
5280                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5281                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5282                                 break; }
5283
5284                                 case 3: {
5285                                         NDR_CHECK(ndr_push_align(ndr, 4));
5286                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5287                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5288                                 break; }
5289
5290                                 case 4: {
5291                                         NDR_CHECK(ndr_push_align(ndr, 5));
5292                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5293                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5294                                 break; }
5295
5296                                 default: {
5297                                 break; }
5298
5299                         }
5300                 }
5301                 if (ndr_flags & NDR_BUFFERS) {
5302                         int level = ndr_push_get_switch_value(ndr, r);
5303                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
5304                         switch (level) {
5305                                 case 1:
5306                                         NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5307                                 break;
5308
5309                                 case 2:
5310                                         NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5311                                 break;
5312
5313                                 case 3:
5314                                 break;
5315
5316                                 case 4:
5317                                         NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5318                                 break;
5319
5320                                 default:
5321                                 break;
5322
5323                         }
5324                 }
5325                 ndr->flags = _flags_save_UNION;
5326         }
5327         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
5328         return NDR_ERR_SUCCESS;
5329 }
5330
5331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
5332 {
5333         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
5334         int level;
5335         {
5336                 uint32_t _flags_save_UNION = ndr->flags;
5337                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5338                 level = ndr_pull_get_switch_value(ndr, r);
5339                 if (ndr_flags & NDR_SCALARS) {
5340                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
5341                         switch (level) {
5342                                 case 1: {
5343                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5344                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5345                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5346                                 break; }
5347
5348                                 case 2: {
5349                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5350                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5351                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5352                                 break; }
5353
5354                                 case 3: {
5355                                         NDR_CHECK(ndr_pull_align(ndr, 4));
5356                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5357                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5358                                 break; }
5359
5360                                 case 4: {
5361                                         NDR_CHECK(ndr_pull_align(ndr, 5));
5362                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5363                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5364                                 break; }
5365
5366                                 default: {
5367                                 break; }
5368
5369                         }
5370                 }
5371                 if (ndr_flags & NDR_BUFFERS) {
5372                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5373                         switch (level) {
5374                                 case 1:
5375                                         NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5376                                 break;
5377
5378                                 case 2:
5379                                         NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5380                                 break;
5381
5382                                 case 3:
5383                                 break;
5384
5385                                 case 4:
5386                                         NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5387                                 break;
5388
5389                                 default:
5390                                 break;
5391
5392                         }
5393                 }
5394                 ndr->flags = _flags_save_UNION;
5395         }
5396         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5397         return NDR_ERR_SUCCESS;
5398 }
5399
5400 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5401 {
5402         int level;
5403         {
5404                 uint32_t _flags_save_UNION = ndr->flags;
5405                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
5406                 level = ndr_print_get_switch_value(ndr, r);
5407                 ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5408                 switch (level) {
5409                         case 1:
5410                                 ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5411                         break;
5412
5413                         case 2:
5414                                 ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5415                         break;
5416
5417                         case 3:
5418                                 ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5419                         break;
5420
5421                         case 4:
5422                                 ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5423                         break;
5424
5425                         default:
5426                         break;
5427
5428                 }
5429                 ndr->flags = _flags_save_UNION;
5430         }
5431 }
5432
5433 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5434 {
5435         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
5436         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5437 }
5438
5439 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5440 {
5441         if (ndr_flags & NDR_SCALARS) {
5442                 NDR_CHECK(ndr_push_align(ndr, 5));
5443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5450                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5455                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5456                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5457         }
5458         if (ndr_flags & NDR_BUFFERS) {
5459                 if (r->printer_name) {
5460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5462                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5463                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5464                 }
5465                 if (r->server_name) {
5466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5469                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5470                 }
5471                 if (r->user_name) {
5472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5476                 }
5477                 if (r->document_name) {
5478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5480                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5481                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5482                 }
5483                 if (r->data_type) {
5484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5487                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5488                 }
5489                 if (r->text_status) {
5490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5491                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5492                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5493                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5494                 }
5495         }
5496         return NDR_ERR_SUCCESS;
5497 }
5498
5499 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5500 {
5501         uint32_t _ptr_printer_name;
5502         TALLOC_CTX *_mem_save_printer_name_0;
5503         uint32_t _ptr_server_name;
5504         TALLOC_CTX *_mem_save_server_name_0;
5505         uint32_t _ptr_user_name;
5506         TALLOC_CTX *_mem_save_user_name_0;
5507         uint32_t _ptr_document_name;
5508         TALLOC_CTX *_mem_save_document_name_0;
5509         uint32_t _ptr_data_type;
5510         TALLOC_CTX *_mem_save_data_type_0;
5511         uint32_t _ptr_text_status;
5512         TALLOC_CTX *_mem_save_text_status_0;
5513         if (ndr_flags & NDR_SCALARS) {
5514                 NDR_CHECK(ndr_pull_align(ndr, 5));
5515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5517                 if (_ptr_printer_name) {
5518                         NDR_PULL_ALLOC(ndr, r->printer_name);
5519                 } else {
5520                         r->printer_name = NULL;
5521                 }
5522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5523                 if (_ptr_server_name) {
5524                         NDR_PULL_ALLOC(ndr, r->server_name);
5525                 } else {
5526                         r->server_name = NULL;
5527                 }
5528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5529                 if (_ptr_user_name) {
5530                         NDR_PULL_ALLOC(ndr, r->user_name);
5531                 } else {
5532                         r->user_name = NULL;
5533                 }
5534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5535                 if (_ptr_document_name) {
5536                         NDR_PULL_ALLOC(ndr, r->document_name);
5537                 } else {
5538                         r->document_name = NULL;
5539                 }
5540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5541                 if (_ptr_data_type) {
5542                         NDR_PULL_ALLOC(ndr, r->data_type);
5543                 } else {
5544                         r->data_type = NULL;
5545                 }
5546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5547                 if (_ptr_text_status) {
5548                         NDR_PULL_ALLOC(ndr, r->text_status);
5549                 } else {
5550                         r->text_status = NULL;
5551                 }
5552                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5554                 if (r->priority > 99) {
5555                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5556                 }
5557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5560                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5561                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5562         }
5563         if (ndr_flags & NDR_BUFFERS) {
5564                 if (r->printer_name) {
5565                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5569                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_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->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5575                 }
5576                 if (r->server_name) {
5577                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5581                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_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->server_name), ndr_get_array_length(ndr, &r->server_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5587                 }
5588                 if (r->user_name) {
5589                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5593                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_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->user_name), ndr_get_array_length(ndr, &r->user_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5599                 }
5600                 if (r->document_name) {
5601                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5605                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
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->document_name), ndr_get_array_length(ndr, &r->document_name));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5611                 }
5612                 if (r->data_type) {
5613                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5617                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
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->data_type), ndr_get_array_length(ndr, &r->data_type));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5623                 }
5624                 if (r->text_status) {
5625                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5629                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
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->text_status), ndr_get_array_length(ndr, &r->text_status));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5635                 }
5636         }
5637         return NDR_ERR_SUCCESS;
5638 }
5639
5640 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5641 {
5642         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5643         ndr->depth++;
5644         ndr_print_uint32(ndr, "job_id", r->job_id);
5645         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5646         ndr->depth++;
5647         if (r->printer_name) {
5648                 ndr_print_string(ndr, "printer_name", r->printer_name);
5649         }
5650         ndr->depth--;
5651         ndr_print_ptr(ndr, "server_name", r->server_name);
5652         ndr->depth++;
5653         if (r->server_name) {
5654                 ndr_print_string(ndr, "server_name", r->server_name);
5655         }
5656         ndr->depth--;
5657         ndr_print_ptr(ndr, "user_name", r->user_name);
5658         ndr->depth++;
5659         if (r->user_name) {
5660                 ndr_print_string(ndr, "user_name", r->user_name);
5661         }
5662         ndr->depth--;
5663         ndr_print_ptr(ndr, "document_name", r->document_name);
5664         ndr->depth++;
5665         if (r->document_name) {
5666                 ndr_print_string(ndr, "document_name", r->document_name);
5667         }
5668         ndr->depth--;
5669         ndr_print_ptr(ndr, "data_type", r->data_type);
5670         ndr->depth++;
5671         if (r->data_type) {
5672                 ndr_print_string(ndr, "data_type", r->data_type);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "text_status", r->text_status);
5676         ndr->depth++;
5677         if (r->text_status) {
5678                 ndr_print_string(ndr, "text_status", r->text_status);
5679         }
5680         ndr->depth--;
5681         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5682         ndr_print_uint32(ndr, "priority", r->priority);
5683         ndr_print_uint32(ndr, "position", r->position);
5684         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5685         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5686         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5687         ndr->depth--;
5688 }
5689
5690 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5691 {
5692         if (ndr_flags & NDR_SCALARS) {
5693                 NDR_CHECK(ndr_push_align(ndr, 5));
5694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5707                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5714                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5717                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5718         }
5719         if (ndr_flags & NDR_BUFFERS) {
5720                 if (r->printer_name) {
5721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5725                 }
5726                 if (r->server_name) {
5727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5731                 }
5732                 if (r->user_name) {
5733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5737                 }
5738                 if (r->document_name) {
5739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5743                 }
5744                 if (r->notify_name) {
5745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5749                 }
5750                 if (r->data_type) {
5751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5755                 }
5756                 if (r->print_processor) {
5757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5761                 }
5762                 if (r->parameters) {
5763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5767                 }
5768                 if (r->driver_name) {
5769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5772                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5773                 }
5774                 if (r->text_status) {
5775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5779                 }
5780         }
5781         return NDR_ERR_SUCCESS;
5782 }
5783
5784 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5785 {
5786         uint32_t _ptr_printer_name;
5787         TALLOC_CTX *_mem_save_printer_name_0;
5788         uint32_t _ptr_server_name;
5789         TALLOC_CTX *_mem_save_server_name_0;
5790         uint32_t _ptr_user_name;
5791         TALLOC_CTX *_mem_save_user_name_0;
5792         uint32_t _ptr_document_name;
5793         TALLOC_CTX *_mem_save_document_name_0;
5794         uint32_t _ptr_notify_name;
5795         TALLOC_CTX *_mem_save_notify_name_0;
5796         uint32_t _ptr_data_type;
5797         TALLOC_CTX *_mem_save_data_type_0;
5798         uint32_t _ptr_print_processor;
5799         TALLOC_CTX *_mem_save_print_processor_0;
5800         uint32_t _ptr_parameters;
5801         TALLOC_CTX *_mem_save_parameters_0;
5802         uint32_t _ptr_driver_name;
5803         TALLOC_CTX *_mem_save_driver_name_0;
5804         uint32_t _ptr_text_status;
5805         TALLOC_CTX *_mem_save_text_status_0;
5806         if (ndr_flags & NDR_SCALARS) {
5807                 NDR_CHECK(ndr_pull_align(ndr, 5));
5808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5810                 if (_ptr_printer_name) {
5811                         NDR_PULL_ALLOC(ndr, r->printer_name);
5812                 } else {
5813                         r->printer_name = NULL;
5814                 }
5815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5816                 if (_ptr_server_name) {
5817                         NDR_PULL_ALLOC(ndr, r->server_name);
5818                 } else {
5819                         r->server_name = NULL;
5820                 }
5821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5822                 if (_ptr_user_name) {
5823                         NDR_PULL_ALLOC(ndr, r->user_name);
5824                 } else {
5825                         r->user_name = NULL;
5826                 }
5827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5828                 if (_ptr_document_name) {
5829                         NDR_PULL_ALLOC(ndr, r->document_name);
5830                 } else {
5831                         r->document_name = NULL;
5832                 }
5833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5834                 if (_ptr_notify_name) {
5835                         NDR_PULL_ALLOC(ndr, r->notify_name);
5836                 } else {
5837                         r->notify_name = NULL;
5838                 }
5839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5840                 if (_ptr_data_type) {
5841                         NDR_PULL_ALLOC(ndr, r->data_type);
5842                 } else {
5843                         r->data_type = NULL;
5844                 }
5845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5846                 if (_ptr_print_processor) {
5847                         NDR_PULL_ALLOC(ndr, r->print_processor);
5848                 } else {
5849                         r->print_processor = NULL;
5850                 }
5851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5852                 if (_ptr_parameters) {
5853                         NDR_PULL_ALLOC(ndr, r->parameters);
5854                 } else {
5855                         r->parameters = NULL;
5856                 }
5857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5858                 if (_ptr_driver_name) {
5859                         NDR_PULL_ALLOC(ndr, r->driver_name);
5860                 } else {
5861                         r->driver_name = NULL;
5862                 }
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5865                 if (_ptr_text_status) {
5866                         NDR_PULL_ALLOC(ndr, r->text_status);
5867                 } else {
5868                         r->text_status = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5871                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5873                 if (r->priority > 99) {
5874                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5875                 }
5876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5881                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5884                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5885         }
5886         if (ndr_flags & NDR_BUFFERS) {
5887                 if (r->printer_name) {
5888                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5889                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5890                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5891                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5892                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5893                                 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));
5894                         }
5895                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5896                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5898                 }
5899                 if (r->server_name) {
5900                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5901                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5902                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5903                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5904                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5905                                 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));
5906                         }
5907                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5908                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5909                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5910                 }
5911                 if (r->user_name) {
5912                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5913                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5914                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5915                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5916                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5917                                 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));
5918                         }
5919                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5920                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5922                 }
5923                 if (r->document_name) {
5924                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5925                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5926                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5927                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5928                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5929                                 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));
5930                         }
5931                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5932                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5934                 }
5935                 if (r->notify_name) {
5936                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5937                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5938                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5939                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5940                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5941                                 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));
5942                         }
5943                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5944                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5945                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5946                 }
5947                 if (r->data_type) {
5948                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5949                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5952                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5953                                 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));
5954                         }
5955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5958                 }
5959                 if (r->print_processor) {
5960                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5961                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5962                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5963                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5964                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5965                                 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));
5966                         }
5967                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5968                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5970                 }
5971                 if (r->parameters) {
5972                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5973                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5974                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5975                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5976                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5977                                 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));
5978                         }
5979                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5980                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5981                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5982                 }
5983                 if (r->driver_name) {
5984                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5985                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5986                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5987                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5988                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5989                                 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));
5990                         }
5991                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5992                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5993                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5994                 }
5995                 if (r->text_status) {
5996                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5997                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5998                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5999                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6000                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6001                                 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));
6002                         }
6003                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6004                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6006                 }
6007         }
6008         return NDR_ERR_SUCCESS;
6009 }
6010
6011 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
6012 {
6013         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
6014         ndr->depth++;
6015         ndr_print_uint32(ndr, "job_id", r->job_id);
6016         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6017         ndr->depth++;
6018         if (r->printer_name) {
6019                 ndr_print_string(ndr, "printer_name", r->printer_name);
6020         }
6021         ndr->depth--;
6022         ndr_print_ptr(ndr, "server_name", r->server_name);
6023         ndr->depth++;
6024         if (r->server_name) {
6025                 ndr_print_string(ndr, "server_name", r->server_name);
6026         }
6027         ndr->depth--;
6028         ndr_print_ptr(ndr, "user_name", r->user_name);
6029         ndr->depth++;
6030         if (r->user_name) {
6031                 ndr_print_string(ndr, "user_name", r->user_name);
6032         }
6033         ndr->depth--;
6034         ndr_print_ptr(ndr, "document_name", r->document_name);
6035         ndr->depth++;
6036         if (r->document_name) {
6037                 ndr_print_string(ndr, "document_name", r->document_name);
6038         }
6039         ndr->depth--;
6040         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6041         ndr->depth++;
6042         if (r->notify_name) {
6043                 ndr_print_string(ndr, "notify_name", r->notify_name);
6044         }
6045         ndr->depth--;
6046         ndr_print_ptr(ndr, "data_type", r->data_type);
6047         ndr->depth++;
6048         if (r->data_type) {
6049                 ndr_print_string(ndr, "data_type", r->data_type);
6050         }
6051         ndr->depth--;
6052         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6053         ndr->depth++;
6054         if (r->print_processor) {
6055                 ndr_print_string(ndr, "print_processor", r->print_processor);
6056         }
6057         ndr->depth--;
6058         ndr_print_ptr(ndr, "parameters", r->parameters);
6059         ndr->depth++;
6060         if (r->parameters) {
6061                 ndr_print_string(ndr, "parameters", r->parameters);
6062         }
6063         ndr->depth--;
6064         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6065         ndr->depth++;
6066         if (r->driver_name) {
6067                 ndr_print_string(ndr, "driver_name", r->driver_name);
6068         }
6069         ndr->depth--;
6070         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6071         ndr_print_ptr(ndr, "text_status", r->text_status);
6072         ndr->depth++;
6073         if (r->text_status) {
6074                 ndr_print_string(ndr, "text_status", r->text_status);
6075         }
6076         ndr->depth--;
6077         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6078         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6079         ndr_print_uint32(ndr, "priority", r->priority);
6080         ndr_print_uint32(ndr, "position", r->position);
6081         ndr_print_uint32(ndr, "start_time", r->start_time);
6082         ndr_print_uint32(ndr, "until_time", r->until_time);
6083         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6084         ndr_print_uint32(ndr, "size", r->size);
6085         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6086         ndr_print_uint32(ndr, "time", r->time);
6087         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6088         ndr->depth--;
6089 }
6090
6091 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
6092 {
6093         if (ndr_flags & NDR_SCALARS) {
6094                 NDR_CHECK(ndr_push_align(ndr, 5));
6095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
6096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
6097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
6098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
6099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
6100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
6101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
6102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
6103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
6106                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
6107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
6108                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
6109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
6111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
6112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
6113                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
6115                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
6116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
6117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
6118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
6119                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6120         }
6121         if (ndr_flags & NDR_BUFFERS) {
6122                 if (r->printer_name) {
6123                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
6124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
6126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6127                 }
6128                 if (r->server_name) {
6129                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6130                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
6132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6133                 }
6134                 if (r->user_name) {
6135                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
6136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
6138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6139                 }
6140                 if (r->document_name) {
6141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6144                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6145                 }
6146                 if (r->notify_name) {
6147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
6148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
6150                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6151                 }
6152                 if (r->data_type) {
6153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
6154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
6156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6157                 }
6158                 if (r->print_processor) {
6159                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
6162                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6163                 }
6164                 if (r->parameters) {
6165                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6169                 }
6170                 if (r->driver_name) {
6171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6175                 }
6176                 if (r->text_status) {
6177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
6178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
6180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6181                 }
6182         }
6183         return NDR_ERR_SUCCESS;
6184 }
6185
6186 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
6187 {
6188         uint32_t _ptr_printer_name;
6189         TALLOC_CTX *_mem_save_printer_name_0;
6190         uint32_t _ptr_server_name;
6191         TALLOC_CTX *_mem_save_server_name_0;
6192         uint32_t _ptr_user_name;
6193         TALLOC_CTX *_mem_save_user_name_0;
6194         uint32_t _ptr_document_name;
6195         TALLOC_CTX *_mem_save_document_name_0;
6196         uint32_t _ptr_notify_name;
6197         TALLOC_CTX *_mem_save_notify_name_0;
6198         uint32_t _ptr_data_type;
6199         TALLOC_CTX *_mem_save_data_type_0;
6200         uint32_t _ptr_print_processor;
6201         TALLOC_CTX *_mem_save_print_processor_0;
6202         uint32_t _ptr_parameters;
6203         TALLOC_CTX *_mem_save_parameters_0;
6204         uint32_t _ptr_driver_name;
6205         TALLOC_CTX *_mem_save_driver_name_0;
6206         uint32_t _ptr_text_status;
6207         TALLOC_CTX *_mem_save_text_status_0;
6208         if (ndr_flags & NDR_SCALARS) {
6209                 NDR_CHECK(ndr_pull_align(ndr, 5));
6210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
6211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
6212                 if (_ptr_printer_name) {
6213                         NDR_PULL_ALLOC(ndr, r->printer_name);
6214                 } else {
6215                         r->printer_name = NULL;
6216                 }
6217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
6218                 if (_ptr_server_name) {
6219                         NDR_PULL_ALLOC(ndr, r->server_name);
6220                 } else {
6221                         r->server_name = NULL;
6222                 }
6223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
6224                 if (_ptr_user_name) {
6225                         NDR_PULL_ALLOC(ndr, r->user_name);
6226                 } else {
6227                         r->user_name = NULL;
6228                 }
6229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
6230                 if (_ptr_document_name) {
6231                         NDR_PULL_ALLOC(ndr, r->document_name);
6232                 } else {
6233                         r->document_name = NULL;
6234                 }
6235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
6236                 if (_ptr_notify_name) {
6237                         NDR_PULL_ALLOC(ndr, r->notify_name);
6238                 } else {
6239                         r->notify_name = NULL;
6240                 }
6241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
6242                 if (_ptr_data_type) {
6243                         NDR_PULL_ALLOC(ndr, r->data_type);
6244                 } else {
6245                         r->data_type = NULL;
6246                 }
6247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
6248                 if (_ptr_print_processor) {
6249                         NDR_PULL_ALLOC(ndr, r->print_processor);
6250                 } else {
6251                         r->print_processor = NULL;
6252                 }
6253                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6254                 if (_ptr_parameters) {
6255                         NDR_PULL_ALLOC(ndr, r->parameters);
6256                 } else {
6257                         r->parameters = NULL;
6258                 }
6259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6260                 if (_ptr_driver_name) {
6261                         NDR_PULL_ALLOC(ndr, r->driver_name);
6262                 } else {
6263                         r->driver_name = NULL;
6264                 }
6265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
6266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
6267                 if (_ptr_text_status) {
6268                         NDR_PULL_ALLOC(ndr, r->text_status);
6269                 } else {
6270                         r->text_status = NULL;
6271                 }
6272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
6273                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
6274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6275                 if (r->priority > 99) {
6276                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6277                 }
6278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
6279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
6280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
6281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6282                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
6283                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
6284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
6285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
6286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
6287                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6288         }
6289         if (ndr_flags & NDR_BUFFERS) {
6290                 if (r->printer_name) {
6291                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6292                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
6293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
6294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
6295                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
6296                                 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));
6297                         }
6298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
6299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
6300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
6301                 }
6302                 if (r->server_name) {
6303                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
6305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
6306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
6307                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
6308                                 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));
6309                         }
6310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
6311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
6312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
6313                 }
6314                 if (r->user_name) {
6315                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6316                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
6317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
6318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
6319                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
6320                                 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));
6321                         }
6322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
6323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
6324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
6325                 }
6326                 if (r->document_name) {
6327                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6328                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
6329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
6330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
6331                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
6332                                 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));
6333                         }
6334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
6335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
6336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
6337                 }
6338                 if (r->notify_name) {
6339                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6340                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
6341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
6342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
6343                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
6344                                 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));
6345                         }
6346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6349                 }
6350                 if (r->data_type) {
6351                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6352                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6353                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6354                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6355                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6356                                 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));
6357                         }
6358                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6361                 }
6362                 if (r->print_processor) {
6363                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6364                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6367                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6368                                 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));
6369                         }
6370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6373                 }
6374                 if (r->parameters) {
6375                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6376                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6379                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6380                                 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));
6381                         }
6382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6385                 }
6386                 if (r->driver_name) {
6387                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6388                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6391                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6392                                 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));
6393                         }
6394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6397                 }
6398                 if (r->text_status) {
6399                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6400                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6403                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6404                                 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));
6405                         }
6406                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6407                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6409                 }
6410         }
6411         return NDR_ERR_SUCCESS;
6412 }
6413
6414 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6415 {
6416         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6417         ndr->depth++;
6418         ndr_print_uint32(ndr, "job_id", r->job_id);
6419         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6420         ndr->depth++;
6421         if (r->printer_name) {
6422                 ndr_print_string(ndr, "printer_name", r->printer_name);
6423         }
6424         ndr->depth--;
6425         ndr_print_ptr(ndr, "server_name", r->server_name);
6426         ndr->depth++;
6427         if (r->server_name) {
6428                 ndr_print_string(ndr, "server_name", r->server_name);
6429         }
6430         ndr->depth--;
6431         ndr_print_ptr(ndr, "user_name", r->user_name);
6432         ndr->depth++;
6433         if (r->user_name) {
6434                 ndr_print_string(ndr, "user_name", r->user_name);
6435         }
6436         ndr->depth--;
6437         ndr_print_ptr(ndr, "document_name", r->document_name);
6438         ndr->depth++;
6439         if (r->document_name) {
6440                 ndr_print_string(ndr, "document_name", r->document_name);
6441         }
6442         ndr->depth--;
6443         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6444         ndr->depth++;
6445         if (r->notify_name) {
6446                 ndr_print_string(ndr, "notify_name", r->notify_name);
6447         }
6448         ndr->depth--;
6449         ndr_print_ptr(ndr, "data_type", r->data_type);
6450         ndr->depth++;
6451         if (r->data_type) {
6452                 ndr_print_string(ndr, "data_type", r->data_type);
6453         }
6454         ndr->depth--;
6455         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6456         ndr->depth++;
6457         if (r->print_processor) {
6458                 ndr_print_string(ndr, "print_processor", r->print_processor);
6459         }
6460         ndr->depth--;
6461         ndr_print_ptr(ndr, "parameters", r->parameters);
6462         ndr->depth++;
6463         if (r->parameters) {
6464                 ndr_print_string(ndr, "parameters", r->parameters);
6465         }
6466         ndr->depth--;
6467         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6468         ndr->depth++;
6469         if (r->driver_name) {
6470                 ndr_print_string(ndr, "driver_name", r->driver_name);
6471         }
6472         ndr->depth--;
6473         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6474         ndr_print_ptr(ndr, "text_status", r->text_status);
6475         ndr->depth++;
6476         if (r->text_status) {
6477                 ndr_print_string(ndr, "text_status", r->text_status);
6478         }
6479         ndr->depth--;
6480         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6481         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6482         ndr_print_uint32(ndr, "priority", r->priority);
6483         ndr_print_uint32(ndr, "position", r->position);
6484         ndr_print_uint32(ndr, "start_time", r->start_time);
6485         ndr_print_uint32(ndr, "until_time", r->until_time);
6486         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6487         ndr_print_uint32(ndr, "size", r->size);
6488         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6489         ndr_print_uint32(ndr, "time", r->time);
6490         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6491         ndr_print_uint32(ndr, "size_high", r->size_high);
6492         ndr->depth--;
6493 }
6494
6495 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6496 {
6497         if (ndr_flags & NDR_SCALARS) {
6498                 int level = ndr_push_get_switch_value(ndr, r);
6499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6500                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6501                 switch (level) {
6502                         case 1: {
6503                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6504                         break; }
6505
6506                         case 2: {
6507                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6508                         break; }
6509
6510                         case 3: {
6511                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6512                         break; }
6513
6514                         case 4: {
6515                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6516                         break; }
6517
6518                         default: {
6519                         break; }
6520
6521                 }
6522         }
6523         if (ndr_flags & NDR_BUFFERS) {
6524                 int level = ndr_push_get_switch_value(ndr, r);
6525                 switch (level) {
6526                         case 1:
6527                                 if (r->info1) {
6528                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6529                                 }
6530                         break;
6531
6532                         case 2:
6533                                 if (r->info2) {
6534                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6535                                 }
6536                         break;
6537
6538                         case 3:
6539                                 if (r->info3) {
6540                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6541                                 }
6542                         break;
6543
6544                         case 4:
6545                                 if (r->info4) {
6546                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6547                                 }
6548                         break;
6549
6550                         default:
6551                         break;
6552
6553                 }
6554         }
6555         return NDR_ERR_SUCCESS;
6556 }
6557
6558 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6559 {
6560         int level;
6561         uint32_t _level;
6562         TALLOC_CTX *_mem_save_info1_0;
6563         TALLOC_CTX *_mem_save_info2_0;
6564         TALLOC_CTX *_mem_save_info3_0;
6565         TALLOC_CTX *_mem_save_info4_0;
6566         level = ndr_pull_get_switch_value(ndr, r);
6567         if (ndr_flags & NDR_SCALARS) {
6568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6569                 if (_level != level) {
6570                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6571                 }
6572                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6573                 switch (level) {
6574                         case 1: {
6575                                 uint32_t _ptr_info1;
6576                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6577                                 if (_ptr_info1) {
6578                                         NDR_PULL_ALLOC(ndr, r->info1);
6579                                 } else {
6580                                         r->info1 = NULL;
6581                                 }
6582                         break; }
6583
6584                         case 2: {
6585                                 uint32_t _ptr_info2;
6586                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6587                                 if (_ptr_info2) {
6588                                         NDR_PULL_ALLOC(ndr, r->info2);
6589                                 } else {
6590                                         r->info2 = NULL;
6591                                 }
6592                         break; }
6593
6594                         case 3: {
6595                                 uint32_t _ptr_info3;
6596                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6597                                 if (_ptr_info3) {
6598                                         NDR_PULL_ALLOC(ndr, r->info3);
6599                                 } else {
6600                                         r->info3 = NULL;
6601                                 }
6602                         break; }
6603
6604                         case 4: {
6605                                 uint32_t _ptr_info4;
6606                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6607                                 if (_ptr_info4) {
6608                                         NDR_PULL_ALLOC(ndr, r->info4);
6609                                 } else {
6610                                         r->info4 = NULL;
6611                                 }
6612                         break; }
6613
6614                         default: {
6615                         break; }
6616
6617                 }
6618         }
6619         if (ndr_flags & NDR_BUFFERS) {
6620                 switch (level) {
6621                         case 1:
6622                                 if (r->info1) {
6623                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6625                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6627                                 }
6628                         break;
6629
6630                         case 2:
6631                                 if (r->info2) {
6632                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6633                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6634                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6635                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6636                                 }
6637                         break;
6638
6639                         case 3:
6640                                 if (r->info3) {
6641                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6642                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6643                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6644                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6645                                 }
6646                         break;
6647
6648                         case 4:
6649                                 if (r->info4) {
6650                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6652                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6654                                 }
6655                         break;
6656
6657                         default:
6658                         break;
6659
6660                 }
6661         }
6662         return NDR_ERR_SUCCESS;
6663 }
6664
6665 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6666 {
6667         int level;
6668         level = ndr_print_get_switch_value(ndr, r);
6669         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6670         switch (level) {
6671                 case 1:
6672                         ndr_print_ptr(ndr, "info1", r->info1);
6673                         ndr->depth++;
6674                         if (r->info1) {
6675                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6676                         }
6677                         ndr->depth--;
6678                 break;
6679
6680                 case 2:
6681                         ndr_print_ptr(ndr, "info2", r->info2);
6682                         ndr->depth++;
6683                         if (r->info2) {
6684                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6685                         }
6686                         ndr->depth--;
6687                 break;
6688
6689                 case 3:
6690                         ndr_print_ptr(ndr, "info3", r->info3);
6691                         ndr->depth++;
6692                         if (r->info3) {
6693                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6694                         }
6695                         ndr->depth--;
6696                 break;
6697
6698                 case 4:
6699                         ndr_print_ptr(ndr, "info4", r->info4);
6700                         ndr->depth++;
6701                         if (r->info4) {
6702                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6703                         }
6704                         ndr->depth--;
6705                 break;
6706
6707                 default:
6708                 break;
6709
6710         }
6711 }
6712
6713 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6714 {
6715         if (ndr_flags & NDR_SCALARS) {
6716                 NDR_CHECK(ndr_push_align(ndr, 5));
6717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6718                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6719                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6720                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6721         }
6722         if (ndr_flags & NDR_BUFFERS) {
6723                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6724         }
6725         return NDR_ERR_SUCCESS;
6726 }
6727
6728 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6729 {
6730         if (ndr_flags & NDR_SCALARS) {
6731                 NDR_CHECK(ndr_pull_align(ndr, 5));
6732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6733                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6734                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6735                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6736         }
6737         if (ndr_flags & NDR_BUFFERS) {
6738                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6739         }
6740         return NDR_ERR_SUCCESS;
6741 }
6742
6743 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6744 {
6745         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6746         ndr->depth++;
6747         ndr_print_uint32(ndr, "level", r->level);
6748         ndr_print_set_switch_value(ndr, &r->info, r->level);
6749         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6750         ndr->depth--;
6751 }
6752
6753 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6754 {
6755         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6756         return NDR_ERR_SUCCESS;
6757 }
6758
6759 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6760 {
6761         uint32_t v;
6762         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6763         *r = v;
6764         return NDR_ERR_SUCCESS;
6765 }
6766
6767 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6768 {
6769         const char *val = NULL;
6770
6771         switch (r) {
6772                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6773                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6774                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6775                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6776                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6777                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6778                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6779                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6780                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6781         }
6782         ndr_print_enum(ndr, name, "ENUM", val, r);
6783 }
6784
6785 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6786 {
6787         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6788         return NDR_ERR_SUCCESS;
6789 }
6790
6791 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6792 {
6793         uint32_t v;
6794         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6795         *r = v;
6796         return NDR_ERR_SUCCESS;
6797 }
6798
6799 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6800 {
6801         const char *val = NULL;
6802
6803         switch (r) {
6804                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6805                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6806                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6807                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6808                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6809         }
6810         ndr_print_enum(ndr, name, "ENUM", val, r);
6811 }
6812
6813 static enum ndr_err_code ndr_push_spoolss_Build(struct ndr_push *ndr, int ndr_flags, enum spoolss_Build r)
6814 {
6815         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6816         return NDR_ERR_SUCCESS;
6817 }
6818
6819 static enum ndr_err_code ndr_pull_spoolss_Build(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Build *r)
6820 {
6821         uint32_t v;
6822         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6823         *r = v;
6824         return NDR_ERR_SUCCESS;
6825 }
6826
6827 _PUBLIC_ void ndr_print_spoolss_Build(struct ndr_print *ndr, const char *name, enum spoolss_Build r)
6828 {
6829         const char *val = NULL;
6830
6831         switch (r) {
6832                 case SPOOLSS_DEBUGGING_BUILD: val = "SPOOLSS_DEBUGGING_BUILD"; break;
6833                 case SPOOLSS_RELEASE_BUILD: val = "SPOOLSS_RELEASE_BUILD"; break;
6834         }
6835         ndr_print_enum(ndr, name, "ENUM", val, r);
6836 }
6837
6838 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6839 {
6840         if (ndr_flags & NDR_SCALARS) {
6841                 NDR_CHECK(ndr_push_align(ndr, 5));
6842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6847                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6851                 NDR_CHECK(ndr_push_spoolss_Build(ndr, NDR_SCALARS, r->free_build));
6852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6859                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6866                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6867                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6871                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6872         }
6873         if (ndr_flags & NDR_BUFFERS) {
6874                 if (r->servername) {
6875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6878                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6879                 }
6880                 if (r->printername) {
6881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6883                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6884                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6885                 }
6886         }
6887         return NDR_ERR_SUCCESS;
6888 }
6889
6890 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6891 {
6892         uint32_t _ptr_servername;
6893         TALLOC_CTX *_mem_save_servername_0;
6894         uint32_t _ptr_printername;
6895         TALLOC_CTX *_mem_save_printername_0;
6896         if (ndr_flags & NDR_SCALARS) {
6897                 NDR_CHECK(ndr_pull_align(ndr, 5));
6898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6899                 if (_ptr_servername) {
6900                         NDR_PULL_ALLOC(ndr, r->servername);
6901                 } else {
6902                         r->servername = NULL;
6903                 }
6904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6905                 if (_ptr_printername) {
6906                         NDR_PULL_ALLOC(ndr, r->printername);
6907                 } else {
6908                         r->printername = NULL;
6909                 }
6910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6913                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6917                 NDR_CHECK(ndr_pull_spoolss_Build(ndr, NDR_SCALARS, &r->free_build));
6918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6925                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6928                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6932                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6933                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6937                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6938         }
6939         if (ndr_flags & NDR_BUFFERS) {
6940                 if (r->servername) {
6941                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6942                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6944                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6945                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6946                                 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));
6947                         }
6948                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6949                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6951                 }
6952                 if (r->printername) {
6953                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6954                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6955                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6956                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6957                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6958                                 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));
6959                         }
6960                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6961                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6963                 }
6964         }
6965         return NDR_ERR_SUCCESS;
6966 }
6967
6968 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6969 {
6970         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6971         ndr->depth++;
6972         ndr_print_ptr(ndr, "servername", r->servername);
6973         ndr->depth++;
6974         if (r->servername) {
6975                 ndr_print_string(ndr, "servername", r->servername);
6976         }
6977         ndr->depth--;
6978         ndr_print_ptr(ndr, "printername", r->printername);
6979         ndr->depth++;
6980         if (r->printername) {
6981                 ndr_print_string(ndr, "printername", r->printername);
6982         }
6983         ndr->depth--;
6984         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6985         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6986         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6987         ndr_print_spoolss_Time(ndr, "time", &r->time);
6988         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6989         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6990         ndr_print_uint32(ndr, "version", r->version);
6991         ndr_print_spoolss_Build(ndr, "free_build", r->free_build);
6992         ndr_print_uint32(ndr, "spooling", r->spooling);
6993         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6994         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6995         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6996         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6997         ndr_print_uint32(ndr, "job_error", r->job_error);
6998         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6999         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
7000         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
7001         ndr_print_uint32(ndr, "change_id", r->change_id);
7002         ndr_print_WERROR(ndr, "last_error", r->last_error);
7003         ndr_print_uint32(ndr, "status", r->status);
7004         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
7005         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
7006         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
7007         ndr_print_uint16(ndr, "processor_level", r->processor_level);
7008         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
7009         ndr_print_uint32(ndr, "reserved2", r->reserved2);
7010         ndr_print_uint32(ndr, "reserved3", r->reserved3);
7011         ndr->depth--;
7012 }
7013
7014 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
7015 {
7016         if (ndr_flags & NDR_SCALARS) {
7017                 NDR_CHECK(ndr_push_align(ndr, 5));
7018                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
7019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
7020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
7021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
7022                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7023         }
7024         if (ndr_flags & NDR_BUFFERS) {
7025                 if (r->description) {
7026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
7027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7028                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
7029                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7030                 }
7031                 if (r->name) {
7032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
7033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
7035                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7036                 }
7037                 if (r->comment) {
7038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7042                 }
7043         }
7044         return NDR_ERR_SUCCESS;
7045 }
7046
7047 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
7048 {
7049         uint32_t _ptr_description;
7050         TALLOC_CTX *_mem_save_description_0;
7051         uint32_t _ptr_name;
7052         TALLOC_CTX *_mem_save_name_0;
7053         uint32_t _ptr_comment;
7054         TALLOC_CTX *_mem_save_comment_0;
7055         if (ndr_flags & NDR_SCALARS) {
7056                 NDR_CHECK(ndr_pull_align(ndr, 5));
7057                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
7058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
7059                 if (_ptr_description) {
7060                         NDR_PULL_ALLOC(ndr, r->description);
7061                 } else {
7062                         r->description = NULL;
7063                 }
7064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
7065                 if (_ptr_name) {
7066                         NDR_PULL_ALLOC(ndr, r->name);
7067                 } else {
7068                         r->name = NULL;
7069                 }
7070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7071                 if (_ptr_comment) {
7072                         NDR_PULL_ALLOC(ndr, r->comment);
7073                 } else {
7074                         r->comment = NULL;
7075                 }
7076                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7077         }
7078         if (ndr_flags & NDR_BUFFERS) {
7079                 if (r->description) {
7080                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
7081                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
7082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
7083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
7084                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
7085                                 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));
7086                         }
7087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
7088                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
7089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
7090                 }
7091                 if (r->name) {
7092                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7093                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
7094                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
7095                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
7096                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
7097                                 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));
7098                         }
7099                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
7100                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
7101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
7102                 }
7103                 if (r->comment) {
7104                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7105                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7108                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7109                                 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));
7110                         }
7111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7114                 }
7115         }
7116         return NDR_ERR_SUCCESS;
7117 }
7118
7119 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
7120 {
7121         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
7122         ndr->depth++;
7123         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
7124         ndr_print_ptr(ndr, "description", r->description);
7125         ndr->depth++;
7126         if (r->description) {
7127                 ndr_print_string(ndr, "description", r->description);
7128         }
7129         ndr->depth--;
7130         ndr_print_ptr(ndr, "name", r->name);
7131         ndr->depth++;
7132         if (r->name) {
7133                 ndr_print_string(ndr, "name", r->name);
7134         }
7135         ndr->depth--;
7136         ndr_print_ptr(ndr, "comment", r->comment);
7137         ndr->depth++;
7138         if (r->comment) {
7139                 ndr_print_string(ndr, "comment", r->comment);
7140         }
7141         ndr->depth--;
7142         ndr->depth--;
7143 }
7144
7145 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
7146 {
7147         if (ndr_flags & NDR_SCALARS) {
7148                 NDR_CHECK(ndr_push_align(ndr, 5));
7149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
7152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
7154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
7155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
7156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
7158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
7159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
7160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
7161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
7162                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
7164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
7165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
7166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
7167                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
7169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
7170                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7171         }
7172         if (ndr_flags & NDR_BUFFERS) {
7173                 if (r->servername) {
7174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7178                 }
7179                 if (r->printername) {
7180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7184                 }
7185                 if (r->sharename) {
7186                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
7187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
7189                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7190                 }
7191                 if (r->portname) {
7192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7195                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7196                 }
7197                 if (r->drivername) {
7198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
7199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
7201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7202                 }
7203                 if (r->comment) {
7204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
7207                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7208                 }
7209                 if (r->location) {
7210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
7211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
7213                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7214                 }
7215                 if (r->sepfile) {
7216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
7217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
7219                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7220                 }
7221                 if (r->printprocessor) {
7222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
7223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
7225                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7226                 }
7227                 if (r->datatype) {
7228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
7229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
7231                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7232                 }
7233                 if (r->parameters) {
7234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
7235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7236                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
7237                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7238                 }
7239         }
7240         return NDR_ERR_SUCCESS;
7241 }
7242
7243 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
7244 {
7245         uint32_t _ptr_servername;
7246         TALLOC_CTX *_mem_save_servername_0;
7247         uint32_t _ptr_printername;
7248         TALLOC_CTX *_mem_save_printername_0;
7249         uint32_t _ptr_sharename;
7250         TALLOC_CTX *_mem_save_sharename_0;
7251         uint32_t _ptr_portname;
7252         TALLOC_CTX *_mem_save_portname_0;
7253         uint32_t _ptr_drivername;
7254         TALLOC_CTX *_mem_save_drivername_0;
7255         uint32_t _ptr_comment;
7256         TALLOC_CTX *_mem_save_comment_0;
7257         uint32_t _ptr_location;
7258         TALLOC_CTX *_mem_save_location_0;
7259         uint32_t _ptr_sepfile;
7260         TALLOC_CTX *_mem_save_sepfile_0;
7261         uint32_t _ptr_printprocessor;
7262         TALLOC_CTX *_mem_save_printprocessor_0;
7263         uint32_t _ptr_datatype;
7264         TALLOC_CTX *_mem_save_datatype_0;
7265         uint32_t _ptr_parameters;
7266         TALLOC_CTX *_mem_save_parameters_0;
7267         if (ndr_flags & NDR_SCALARS) {
7268                 NDR_CHECK(ndr_pull_align(ndr, 5));
7269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7270                 if (_ptr_servername) {
7271                         NDR_PULL_ALLOC(ndr, r->servername);
7272                 } else {
7273                         r->servername = NULL;
7274                 }
7275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7276                 if (_ptr_printername) {
7277                         NDR_PULL_ALLOC(ndr, r->printername);
7278                 } else {
7279                         r->printername = NULL;
7280                 }
7281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
7282                 if (_ptr_sharename) {
7283                         NDR_PULL_ALLOC(ndr, r->sharename);
7284                 } else {
7285                         r->sharename = NULL;
7286                 }
7287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7288                 if (_ptr_portname) {
7289                         NDR_PULL_ALLOC(ndr, r->portname);
7290                 } else {
7291                         r->portname = NULL;
7292                 }
7293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
7294                 if (_ptr_drivername) {
7295                         NDR_PULL_ALLOC(ndr, r->drivername);
7296                 } else {
7297                         r->drivername = NULL;
7298                 }
7299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
7300                 if (_ptr_comment) {
7301                         NDR_PULL_ALLOC(ndr, r->comment);
7302                 } else {
7303                         r->comment = NULL;
7304                 }
7305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
7306                 if (_ptr_location) {
7307                         NDR_PULL_ALLOC(ndr, r->location);
7308                 } else {
7309                         r->location = NULL;
7310                 }
7311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
7313                 if (_ptr_sepfile) {
7314                         NDR_PULL_ALLOC(ndr, r->sepfile);
7315                 } else {
7316                         r->sepfile = NULL;
7317                 }
7318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
7319                 if (_ptr_printprocessor) {
7320                         NDR_PULL_ALLOC(ndr, r->printprocessor);
7321                 } else {
7322                         r->printprocessor = NULL;
7323                 }
7324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
7325                 if (_ptr_datatype) {
7326                         NDR_PULL_ALLOC(ndr, r->datatype);
7327                 } else {
7328                         r->datatype = NULL;
7329                 }
7330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
7331                 if (_ptr_parameters) {
7332                         NDR_PULL_ALLOC(ndr, r->parameters);
7333                 } else {
7334                         r->parameters = NULL;
7335                 }
7336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
7337                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
7339                 if (r->priority > 99) {
7340                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7341                 }
7342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7345                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7348                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7349         }
7350         if (ndr_flags & NDR_BUFFERS) {
7351                 if (r->servername) {
7352                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7353                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7356                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7357                                 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));
7358                         }
7359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7362                 }
7363                 if (r->printername) {
7364                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7365                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7368                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7369                                 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));
7370                         }
7371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7374                 }
7375                 if (r->sharename) {
7376                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7377                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7378                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7379                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7380                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7381                                 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));
7382                         }
7383                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7384                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7386                 }
7387                 if (r->portname) {
7388                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7389                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7392                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7393                                 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));
7394                         }
7395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7398                 }
7399                 if (r->drivername) {
7400                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7401                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7404                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7405                                 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));
7406                         }
7407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7410                 }
7411                 if (r->comment) {
7412                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7413                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7416                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7417                                 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));
7418                         }
7419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7422                 }
7423                 if (r->location) {
7424                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7425                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7428                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7429                                 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));
7430                         }
7431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7434                 }
7435                 if (r->sepfile) {
7436                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7437                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7440                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7441                                 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));
7442                         }
7443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7446                 }
7447                 if (r->printprocessor) {
7448                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7449                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7451                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7452                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7453                                 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));
7454                         }
7455                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7456                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7458                 }
7459                 if (r->datatype) {
7460                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7461                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7462                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7463                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7464                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7465                                 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));
7466                         }
7467                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7468                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7469                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7470                 }
7471                 if (r->parameters) {
7472                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7473                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7474                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7475                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7476                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7477                                 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));
7478                         }
7479                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7480                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7481                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7482                 }
7483         }
7484         return NDR_ERR_SUCCESS;
7485 }
7486
7487 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7488 {
7489         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7490         ndr->depth++;
7491         ndr_print_ptr(ndr, "servername", r->servername);
7492         ndr->depth++;
7493         if (r->servername) {
7494                 ndr_print_string(ndr, "servername", r->servername);
7495         }
7496         ndr->depth--;
7497         ndr_print_ptr(ndr, "printername", r->printername);
7498         ndr->depth++;
7499         if (r->printername) {
7500                 ndr_print_string(ndr, "printername", r->printername);
7501         }
7502         ndr->depth--;
7503         ndr_print_ptr(ndr, "sharename", r->sharename);
7504         ndr->depth++;
7505         if (r->sharename) {
7506                 ndr_print_string(ndr, "sharename", r->sharename);
7507         }
7508         ndr->depth--;
7509         ndr_print_ptr(ndr, "portname", r->portname);
7510         ndr->depth++;
7511         if (r->portname) {
7512                 ndr_print_string(ndr, "portname", r->portname);
7513         }
7514         ndr->depth--;
7515         ndr_print_ptr(ndr, "drivername", r->drivername);
7516         ndr->depth++;
7517         if (r->drivername) {
7518                 ndr_print_string(ndr, "drivername", r->drivername);
7519         }
7520         ndr->depth--;
7521         ndr_print_ptr(ndr, "comment", r->comment);
7522         ndr->depth++;
7523         if (r->comment) {
7524                 ndr_print_string(ndr, "comment", r->comment);
7525         }
7526         ndr->depth--;
7527         ndr_print_ptr(ndr, "location", r->location);
7528         ndr->depth++;
7529         if (r->location) {
7530                 ndr_print_string(ndr, "location", r->location);
7531         }
7532         ndr->depth--;
7533         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7534         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7535         ndr->depth++;
7536         if (r->sepfile) {
7537                 ndr_print_string(ndr, "sepfile", r->sepfile);
7538         }
7539         ndr->depth--;
7540         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7541         ndr->depth++;
7542         if (r->printprocessor) {
7543                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7544         }
7545         ndr->depth--;
7546         ndr_print_ptr(ndr, "datatype", r->datatype);
7547         ndr->depth++;
7548         if (r->datatype) {
7549                 ndr_print_string(ndr, "datatype", r->datatype);
7550         }
7551         ndr->depth--;
7552         ndr_print_ptr(ndr, "parameters", r->parameters);
7553         ndr->depth++;
7554         if (r->parameters) {
7555                 ndr_print_string(ndr, "parameters", r->parameters);
7556         }
7557         ndr->depth--;
7558         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7559         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7560         ndr_print_uint32(ndr, "priority", r->priority);
7561         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7562         ndr_print_uint32(ndr, "starttime", r->starttime);
7563         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7564         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7565         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7566         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7567         ndr->depth--;
7568 }
7569
7570 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7571 {
7572         if (ndr_flags & NDR_SCALARS) {
7573                 NDR_CHECK(ndr_push_align(ndr, 4));
7574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7575                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7576         }
7577         if (ndr_flags & NDR_BUFFERS) {
7578         }
7579         return NDR_ERR_SUCCESS;
7580 }
7581
7582 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7583 {
7584         if (ndr_flags & NDR_SCALARS) {
7585                 NDR_CHECK(ndr_pull_align(ndr, 4));
7586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7587                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7588         }
7589         if (ndr_flags & NDR_BUFFERS) {
7590         }
7591         return NDR_ERR_SUCCESS;
7592 }
7593
7594 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7595 {
7596         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7597         ndr->depth++;
7598         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7599         ndr->depth--;
7600 }
7601
7602 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7603 {
7604         if (ndr_flags & NDR_SCALARS) {
7605                 NDR_CHECK(ndr_push_align(ndr, 5));
7606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7608                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7609                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7610         }
7611         if (ndr_flags & NDR_BUFFERS) {
7612                 if (r->printername) {
7613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7614                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7615                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7616                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7617                 }
7618                 if (r->servername) {
7619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7622                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7623                 }
7624         }
7625         return NDR_ERR_SUCCESS;
7626 }
7627
7628 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7629 {
7630         uint32_t _ptr_printername;
7631         TALLOC_CTX *_mem_save_printername_0;
7632         uint32_t _ptr_servername;
7633         TALLOC_CTX *_mem_save_servername_0;
7634         if (ndr_flags & NDR_SCALARS) {
7635                 NDR_CHECK(ndr_pull_align(ndr, 5));
7636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7637                 if (_ptr_printername) {
7638                         NDR_PULL_ALLOC(ndr, r->printername);
7639                 } else {
7640                         r->printername = NULL;
7641                 }
7642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7643                 if (_ptr_servername) {
7644                         NDR_PULL_ALLOC(ndr, r->servername);
7645                 } else {
7646                         r->servername = NULL;
7647                 }
7648                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7649                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7650         }
7651         if (ndr_flags & NDR_BUFFERS) {
7652                 if (r->printername) {
7653                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7654                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7657                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7658                                 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));
7659                         }
7660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7663                 }
7664                 if (r->servername) {
7665                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7666                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7669                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7670                                 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));
7671                         }
7672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7675                 }
7676         }
7677         return NDR_ERR_SUCCESS;
7678 }
7679
7680 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7681 {
7682         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7683         ndr->depth++;
7684         ndr_print_ptr(ndr, "printername", r->printername);
7685         ndr->depth++;
7686         if (r->printername) {
7687                 ndr_print_string(ndr, "printername", r->printername);
7688         }
7689         ndr->depth--;
7690         ndr_print_ptr(ndr, "servername", r->servername);
7691         ndr->depth++;
7692         if (r->servername) {
7693                 ndr_print_string(ndr, "servername", r->servername);
7694         }
7695         ndr->depth--;
7696         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7697         ndr->depth--;
7698 }
7699
7700 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7701 {
7702         if (ndr_flags & NDR_SCALARS) {
7703                 NDR_CHECK(ndr_push_align(ndr, 5));
7704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7706                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7709                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7710         }
7711         if (ndr_flags & NDR_BUFFERS) {
7712                 if (r->printername) {
7713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7717                 }
7718                 if (r->portname) {
7719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7722                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7723                 }
7724         }
7725         return NDR_ERR_SUCCESS;
7726 }
7727
7728 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7729 {
7730         uint32_t _ptr_printername;
7731         TALLOC_CTX *_mem_save_printername_0;
7732         uint32_t _ptr_portname;
7733         TALLOC_CTX *_mem_save_portname_0;
7734         if (ndr_flags & NDR_SCALARS) {
7735                 NDR_CHECK(ndr_pull_align(ndr, 5));
7736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7737                 if (_ptr_printername) {
7738                         NDR_PULL_ALLOC(ndr, r->printername);
7739                 } else {
7740                         r->printername = NULL;
7741                 }
7742                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7743                 if (_ptr_portname) {
7744                         NDR_PULL_ALLOC(ndr, r->portname);
7745                 } else {
7746                         r->portname = NULL;
7747                 }
7748                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7751                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7752         }
7753         if (ndr_flags & NDR_BUFFERS) {
7754                 if (r->printername) {
7755                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7756                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7757                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7758                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7759                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7760                                 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));
7761                         }
7762                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7763                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7765                 }
7766                 if (r->portname) {
7767                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7768                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7769                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7770                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7771                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7772                                 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));
7773                         }
7774                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7775                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7777                 }
7778         }
7779         return NDR_ERR_SUCCESS;
7780 }
7781
7782 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7783 {
7784         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7785         ndr->depth++;
7786         ndr_print_ptr(ndr, "printername", r->printername);
7787         ndr->depth++;
7788         if (r->printername) {
7789                 ndr_print_string(ndr, "printername", r->printername);
7790         }
7791         ndr->depth--;
7792         ndr_print_ptr(ndr, "portname", r->portname);
7793         ndr->depth++;
7794         if (r->portname) {
7795                 ndr_print_string(ndr, "portname", r->portname);
7796         }
7797         ndr->depth--;
7798         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7799         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7800         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7801         ndr->depth--;
7802 }
7803
7804 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7805 {
7806         if (ndr_flags & NDR_SCALARS) {
7807                 NDR_CHECK(ndr_push_align(ndr, 4));
7808                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7809                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7810         }
7811         if (ndr_flags & NDR_BUFFERS) {
7812         }
7813         return NDR_ERR_SUCCESS;
7814 }
7815
7816 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7817 {
7818         if (ndr_flags & NDR_SCALARS) {
7819                 NDR_CHECK(ndr_pull_align(ndr, 4));
7820                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7821                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7822         }
7823         if (ndr_flags & NDR_BUFFERS) {
7824         }
7825         return NDR_ERR_SUCCESS;
7826 }
7827
7828 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7829 {
7830         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7831         ndr->depth++;
7832         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7833         ndr->depth--;
7834 }
7835
7836 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7837 {
7838         if (ndr_flags & NDR_SCALARS) {
7839                 NDR_CHECK(ndr_push_align(ndr, 5));
7840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7841                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7842                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7843         }
7844         if (ndr_flags & NDR_BUFFERS) {
7845                 if (r->guid) {
7846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7848                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7849                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7850                 }
7851         }
7852         return NDR_ERR_SUCCESS;
7853 }
7854
7855 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7856 {
7857         uint32_t _ptr_guid;
7858         TALLOC_CTX *_mem_save_guid_0;
7859         if (ndr_flags & NDR_SCALARS) {
7860                 NDR_CHECK(ndr_pull_align(ndr, 5));
7861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7862                 if (_ptr_guid) {
7863                         NDR_PULL_ALLOC(ndr, r->guid);
7864                 } else {
7865                         r->guid = NULL;
7866                 }
7867                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7868                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7869         }
7870         if (ndr_flags & NDR_BUFFERS) {
7871                 if (r->guid) {
7872                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7873                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7875                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7876                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7877                                 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));
7878                         }
7879                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7880                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7882                 }
7883         }
7884         return NDR_ERR_SUCCESS;
7885 }
7886
7887 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7888 {
7889         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7890         ndr->depth++;
7891         ndr_print_ptr(ndr, "guid", r->guid);
7892         ndr->depth++;
7893         if (r->guid) {
7894                 ndr_print_string(ndr, "guid", r->guid);
7895         }
7896         ndr->depth--;
7897         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7898         ndr->depth--;
7899 }
7900
7901 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7902 {
7903         if (ndr_flags & NDR_SCALARS) {
7904                 NDR_CHECK(ndr_push_align(ndr, 4));
7905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7906                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7907         }
7908         if (ndr_flags & NDR_BUFFERS) {
7909         }
7910         return NDR_ERR_SUCCESS;
7911 }
7912
7913 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7914 {
7915         if (ndr_flags & NDR_SCALARS) {
7916                 NDR_CHECK(ndr_pull_align(ndr, 4));
7917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7918                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7919         }
7920         if (ndr_flags & NDR_BUFFERS) {
7921         }
7922         return NDR_ERR_SUCCESS;
7923 }
7924
7925 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7926 {
7927         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7928         ndr->depth++;
7929         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7930         ndr->depth--;
7931 }
7932
7933 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7934 {
7935         if (ndr_flags & NDR_SCALARS) {
7936                 NDR_CHECK(ndr_push_align(ndr, 4));
7937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7938                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7939         }
7940         if (ndr_flags & NDR_BUFFERS) {
7941         }
7942         return NDR_ERR_SUCCESS;
7943 }
7944
7945 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7946 {
7947         if (ndr_flags & NDR_SCALARS) {
7948                 NDR_CHECK(ndr_pull_align(ndr, 4));
7949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7950                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7951         }
7952         if (ndr_flags & NDR_BUFFERS) {
7953         }
7954         return NDR_ERR_SUCCESS;
7955 }
7956
7957 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7958 {
7959         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7960         ndr->depth++;
7961         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7962         ndr->depth--;
7963 }
7964
7965 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7966 {
7967         if (ndr_flags & NDR_SCALARS) {
7968                 int level = ndr_push_get_switch_value(ndr, r);
7969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7970                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7971                 switch (level) {
7972                         case 0: {
7973                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7974                         break; }
7975
7976                         case 1: {
7977                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7978                         break; }
7979
7980                         case 2: {
7981                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7982                         break; }
7983
7984                         case 3: {
7985                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7986                         break; }
7987
7988                         case 4: {
7989                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7990                         break; }
7991
7992                         case 5: {
7993                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7994                         break; }
7995
7996                         case 6: {
7997                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7998                         break; }
7999
8000                         case 7: {
8001                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
8002                         break; }
8003
8004                         case 8: {
8005                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
8006                         break; }
8007
8008                         case 9: {
8009                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
8010                         break; }
8011
8012                         default: {
8013                         break; }
8014
8015                 }
8016         }
8017         if (ndr_flags & NDR_BUFFERS) {
8018                 int level = ndr_push_get_switch_value(ndr, r);
8019                 switch (level) {
8020                         case 0:
8021                                 if (r->info0) {
8022                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
8023                                 }
8024                         break;
8025
8026                         case 1:
8027                                 if (r->info1) {
8028                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
8029                                 }
8030                         break;
8031
8032                         case 2:
8033                                 if (r->info2) {
8034                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
8035                                 }
8036                         break;
8037
8038                         case 3:
8039                                 if (r->info3) {
8040                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
8041                                 }
8042                         break;
8043
8044                         case 4:
8045                                 if (r->info4) {
8046                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
8047                                 }
8048                         break;
8049
8050                         case 5:
8051                                 if (r->info5) {
8052                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
8053                                 }
8054                         break;
8055
8056                         case 6:
8057                                 if (r->info6) {
8058                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
8059                                 }
8060                         break;
8061
8062                         case 7:
8063                                 if (r->info7) {
8064                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
8065                                 }
8066                         break;
8067
8068                         case 8:
8069                                 if (r->info8) {
8070                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
8071                                 }
8072                         break;
8073
8074                         case 9:
8075                                 if (r->info9) {
8076                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
8077                                 }
8078                         break;
8079
8080                         default:
8081                         break;
8082
8083                 }
8084         }
8085         return NDR_ERR_SUCCESS;
8086 }
8087
8088 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
8089 {
8090         int level;
8091         uint32_t _level;
8092         TALLOC_CTX *_mem_save_info0_0;
8093         TALLOC_CTX *_mem_save_info1_0;
8094         TALLOC_CTX *_mem_save_info2_0;
8095         TALLOC_CTX *_mem_save_info3_0;
8096         TALLOC_CTX *_mem_save_info4_0;
8097         TALLOC_CTX *_mem_save_info5_0;
8098         TALLOC_CTX *_mem_save_info6_0;
8099         TALLOC_CTX *_mem_save_info7_0;
8100         TALLOC_CTX *_mem_save_info8_0;
8101         TALLOC_CTX *_mem_save_info9_0;
8102         level = ndr_pull_get_switch_value(ndr, r);
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8105                 if (_level != level) {
8106                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8107                 }
8108                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8109                 switch (level) {
8110                         case 0: {
8111                                 uint32_t _ptr_info0;
8112                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
8113                                 if (_ptr_info0) {
8114                                         NDR_PULL_ALLOC(ndr, r->info0);
8115                                 } else {
8116                                         r->info0 = NULL;
8117                                 }
8118                         break; }
8119
8120                         case 1: {
8121                                 uint32_t _ptr_info1;
8122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
8123                                 if (_ptr_info1) {
8124                                         NDR_PULL_ALLOC(ndr, r->info1);
8125                                 } else {
8126                                         r->info1 = NULL;
8127                                 }
8128                         break; }
8129
8130                         case 2: {
8131                                 uint32_t _ptr_info2;
8132                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
8133                                 if (_ptr_info2) {
8134                                         NDR_PULL_ALLOC(ndr, r->info2);
8135                                 } else {
8136                                         r->info2 = NULL;
8137                                 }
8138                         break; }
8139
8140                         case 3: {
8141                                 uint32_t _ptr_info3;
8142                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
8143                                 if (_ptr_info3) {
8144                                         NDR_PULL_ALLOC(ndr, r->info3);
8145                                 } else {
8146                                         r->info3 = NULL;
8147                                 }
8148                         break; }
8149
8150                         case 4: {
8151                                 uint32_t _ptr_info4;
8152                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
8153                                 if (_ptr_info4) {
8154                                         NDR_PULL_ALLOC(ndr, r->info4);
8155                                 } else {
8156                                         r->info4 = NULL;
8157                                 }
8158                         break; }
8159
8160                         case 5: {
8161                                 uint32_t _ptr_info5;
8162                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
8163                                 if (_ptr_info5) {
8164                                         NDR_PULL_ALLOC(ndr, r->info5);
8165                                 } else {
8166                                         r->info5 = NULL;
8167                                 }
8168                         break; }
8169
8170                         case 6: {
8171                                 uint32_t _ptr_info6;
8172                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
8173                                 if (_ptr_info6) {
8174                                         NDR_PULL_ALLOC(ndr, r->info6);
8175                                 } else {
8176                                         r->info6 = NULL;
8177                                 }
8178                         break; }
8179
8180                         case 7: {
8181                                 uint32_t _ptr_info7;
8182                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
8183                                 if (_ptr_info7) {
8184                                         NDR_PULL_ALLOC(ndr, r->info7);
8185                                 } else {
8186                                         r->info7 = NULL;
8187                                 }
8188                         break; }
8189
8190                         case 8: {
8191                                 uint32_t _ptr_info8;
8192                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
8193                                 if (_ptr_info8) {
8194                                         NDR_PULL_ALLOC(ndr, r->info8);
8195                                 } else {
8196                                         r->info8 = NULL;
8197                                 }
8198                         break; }
8199
8200                         case 9: {
8201                                 uint32_t _ptr_info9;
8202                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
8203                                 if (_ptr_info9) {
8204                                         NDR_PULL_ALLOC(ndr, r->info9);
8205                                 } else {
8206                                         r->info9 = NULL;
8207                                 }
8208                         break; }
8209
8210                         default: {
8211                         break; }
8212
8213                 }
8214         }
8215         if (ndr_flags & NDR_BUFFERS) {
8216                 switch (level) {
8217                         case 0:
8218                                 if (r->info0) {
8219                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
8220                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
8221                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
8222                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
8223                                 }
8224                         break;
8225
8226                         case 1:
8227                                 if (r->info1) {
8228                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8229                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
8230                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
8231                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
8232                                 }
8233                         break;
8234
8235                         case 2:
8236                                 if (r->info2) {
8237                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
8238                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
8239                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
8240                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
8241                                 }
8242                         break;
8243
8244                         case 3:
8245                                 if (r->info3) {
8246                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
8247                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
8248                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
8249                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
8250                                 }
8251                         break;
8252
8253                         case 4:
8254                                 if (r->info4) {
8255                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
8256                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
8257                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
8258                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
8259                                 }
8260                         break;
8261
8262                         case 5:
8263                                 if (r->info5) {
8264                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
8265                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
8266                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
8267                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
8268                                 }
8269                         break;
8270
8271                         case 6:
8272                                 if (r->info6) {
8273                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
8274                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
8275                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
8276                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
8277                                 }
8278                         break;
8279
8280                         case 7:
8281                                 if (r->info7) {
8282                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
8283                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
8284                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
8285                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
8286                                 }
8287                         break;
8288
8289                         case 8:
8290                                 if (r->info8) {
8291                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
8292                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
8293                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
8294                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
8295                                 }
8296                         break;
8297
8298                         case 9:
8299                                 if (r->info9) {
8300                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
8301                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
8302                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
8303                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
8304                                 }
8305                         break;
8306
8307                         default:
8308                         break;
8309
8310                 }
8311         }
8312         return NDR_ERR_SUCCESS;
8313 }
8314
8315 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
8316 {
8317         int level;
8318         level = ndr_print_get_switch_value(ndr, r);
8319         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
8320         switch (level) {
8321                 case 0:
8322                         ndr_print_ptr(ndr, "info0", r->info0);
8323                         ndr->depth++;
8324                         if (r->info0) {
8325                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
8326                         }
8327                         ndr->depth--;
8328                 break;
8329
8330                 case 1:
8331                         ndr_print_ptr(ndr, "info1", r->info1);
8332                         ndr->depth++;
8333                         if (r->info1) {
8334                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
8335                         }
8336                         ndr->depth--;
8337                 break;
8338
8339                 case 2:
8340                         ndr_print_ptr(ndr, "info2", r->info2);
8341                         ndr->depth++;
8342                         if (r->info2) {
8343                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
8344                         }
8345                         ndr->depth--;
8346                 break;
8347
8348                 case 3:
8349                         ndr_print_ptr(ndr, "info3", r->info3);
8350                         ndr->depth++;
8351                         if (r->info3) {
8352                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
8353                         }
8354                         ndr->depth--;
8355                 break;
8356
8357                 case 4:
8358                         ndr_print_ptr(ndr, "info4", r->info4);
8359                         ndr->depth++;
8360                         if (r->info4) {
8361                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
8362                         }
8363                         ndr->depth--;
8364                 break;
8365
8366                 case 5:
8367                         ndr_print_ptr(ndr, "info5", r->info5);
8368                         ndr->depth++;
8369                         if (r->info5) {
8370                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
8371                         }
8372                         ndr->depth--;
8373                 break;
8374
8375                 case 6:
8376                         ndr_print_ptr(ndr, "info6", r->info6);
8377                         ndr->depth++;
8378                         if (r->info6) {
8379                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8380                         }
8381                         ndr->depth--;
8382                 break;
8383
8384                 case 7:
8385                         ndr_print_ptr(ndr, "info7", r->info7);
8386                         ndr->depth++;
8387                         if (r->info7) {
8388                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8389                         }
8390                         ndr->depth--;
8391                 break;
8392
8393                 case 8:
8394                         ndr_print_ptr(ndr, "info8", r->info8);
8395                         ndr->depth++;
8396                         if (r->info8) {
8397                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8398                         }
8399                         ndr->depth--;
8400                 break;
8401
8402                 case 9:
8403                         ndr_print_ptr(ndr, "info9", r->info9);
8404                         ndr->depth++;
8405                         if (r->info9) {
8406                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8407                         }
8408                         ndr->depth--;
8409                 break;
8410
8411                 default:
8412                 break;
8413
8414         }
8415 }
8416
8417 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8418 {
8419         if (ndr_flags & NDR_SCALARS) {
8420                 NDR_CHECK(ndr_push_align(ndr, 5));
8421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8422                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8423                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8424                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8425         }
8426         if (ndr_flags & NDR_BUFFERS) {
8427                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8428         }
8429         return NDR_ERR_SUCCESS;
8430 }
8431
8432 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8433 {
8434         if (ndr_flags & NDR_SCALARS) {
8435                 NDR_CHECK(ndr_pull_align(ndr, 5));
8436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8437                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8438                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8439                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8440         }
8441         if (ndr_flags & NDR_BUFFERS) {
8442                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8443         }
8444         return NDR_ERR_SUCCESS;
8445 }
8446
8447 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8448 {
8449         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8450         ndr->depth++;
8451         ndr_print_uint32(ndr, "level", r->level);
8452         ndr_print_set_switch_value(ndr, &r->info, r->level);
8453         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8454         ndr->depth--;
8455 }
8456
8457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8458 {
8459         if (ndr_flags & NDR_SCALARS) {
8460                 NDR_CHECK(ndr_push_align(ndr, 4));
8461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8462                 {
8463                         uint32_t _flags_save_string_array = ndr->flags;
8464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8465                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8466                         ndr->flags = _flags_save_string_array;
8467                 }
8468                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8469         }
8470         if (ndr_flags & NDR_BUFFERS) {
8471         }
8472         return NDR_ERR_SUCCESS;
8473 }
8474
8475 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8476 {
8477         if (ndr_flags & NDR_SCALARS) {
8478                 NDR_CHECK(ndr_pull_align(ndr, 4));
8479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8480                 {
8481                         uint32_t _flags_save_string_array = ndr->flags;
8482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8483                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8484                         ndr->flags = _flags_save_string_array;
8485                 }
8486                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8487         }
8488         if (ndr_flags & NDR_BUFFERS) {
8489         }
8490         return NDR_ERR_SUCCESS;
8491 }
8492
8493 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8494 {
8495         ndr_print_struct(ndr, name, "spoolss_StringArray");
8496         ndr->depth++;
8497         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);
8498         ndr_print_string_array(ndr, "string", r->string);
8499         ndr->depth--;
8500 }
8501
8502 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8503 {
8504         if (ndr_flags & NDR_SCALARS) {
8505                 NDR_CHECK(ndr_push_align(ndr, 5));
8506                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8507                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8508         }
8509         if (ndr_flags & NDR_BUFFERS) {
8510                 if (r->driver_name) {
8511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8514                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8515                 }
8516         }
8517         return NDR_ERR_SUCCESS;
8518 }
8519
8520 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8521 {
8522         uint32_t _ptr_driver_name;
8523         TALLOC_CTX *_mem_save_driver_name_0;
8524         if (ndr_flags & NDR_SCALARS) {
8525                 NDR_CHECK(ndr_pull_align(ndr, 5));
8526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8527                 if (_ptr_driver_name) {
8528                         NDR_PULL_ALLOC(ndr, r->driver_name);
8529                 } else {
8530                         r->driver_name = NULL;
8531                 }
8532                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8533         }
8534         if (ndr_flags & NDR_BUFFERS) {
8535                 if (r->driver_name) {
8536                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8537                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8540                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8541                                 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));
8542                         }
8543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8546                 }
8547         }
8548         return NDR_ERR_SUCCESS;
8549 }
8550
8551 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8552 {
8553         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8554         ndr->depth++;
8555         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8556         ndr->depth++;
8557         if (r->driver_name) {
8558                 ndr_print_string(ndr, "driver_name", r->driver_name);
8559         }
8560         ndr->depth--;
8561         ndr->depth--;
8562 }
8563
8564 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8565 {
8566         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8567         return NDR_ERR_SUCCESS;
8568 }
8569
8570 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8571 {
8572         uint32_t v;
8573         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8574         *r = v;
8575         return NDR_ERR_SUCCESS;
8576 }
8577
8578 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8579 {
8580         const char *val = NULL;
8581
8582         switch (r) {
8583                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8584                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8585                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8586                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8587         }
8588         ndr_print_enum(ndr, name, "ENUM", val, r);
8589 }
8590
8591 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8592 {
8593         if (ndr_flags & NDR_SCALARS) {
8594                 NDR_CHECK(ndr_push_align(ndr, 5));
8595                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8596                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8599                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8601                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8602         }
8603         if (ndr_flags & NDR_BUFFERS) {
8604                 if (r->driver_name) {
8605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8608                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8609                 }
8610                 if (r->architecture) {
8611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8613                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8614                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8615                 }
8616                 if (r->driver_path) {
8617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8620                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8621                 }
8622                 if (r->data_file) {
8623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8626                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8627                 }
8628                 if (r->config_file) {
8629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8633                 }
8634         }
8635         return NDR_ERR_SUCCESS;
8636 }
8637
8638 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8639 {
8640         uint32_t _ptr_driver_name;
8641         TALLOC_CTX *_mem_save_driver_name_0;
8642         uint32_t _ptr_architecture;
8643         TALLOC_CTX *_mem_save_architecture_0;
8644         uint32_t _ptr_driver_path;
8645         TALLOC_CTX *_mem_save_driver_path_0;
8646         uint32_t _ptr_data_file;
8647         TALLOC_CTX *_mem_save_data_file_0;
8648         uint32_t _ptr_config_file;
8649         TALLOC_CTX *_mem_save_config_file_0;
8650         if (ndr_flags & NDR_SCALARS) {
8651                 NDR_CHECK(ndr_pull_align(ndr, 5));
8652                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8654                 if (_ptr_driver_name) {
8655                         NDR_PULL_ALLOC(ndr, r->driver_name);
8656                 } else {
8657                         r->driver_name = NULL;
8658                 }
8659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8660                 if (_ptr_architecture) {
8661                         NDR_PULL_ALLOC(ndr, r->architecture);
8662                 } else {
8663                         r->architecture = NULL;
8664                 }
8665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8666                 if (_ptr_driver_path) {
8667                         NDR_PULL_ALLOC(ndr, r->driver_path);
8668                 } else {
8669                         r->driver_path = NULL;
8670                 }
8671                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8672                 if (_ptr_data_file) {
8673                         NDR_PULL_ALLOC(ndr, r->data_file);
8674                 } else {
8675                         r->data_file = NULL;
8676                 }
8677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8678                 if (_ptr_config_file) {
8679                         NDR_PULL_ALLOC(ndr, r->config_file);
8680                 } else {
8681                         r->config_file = NULL;
8682                 }
8683                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8684         }
8685         if (ndr_flags & NDR_BUFFERS) {
8686                 if (r->driver_name) {
8687                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8688                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8691                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8692                                 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));
8693                         }
8694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8697                 }
8698                 if (r->architecture) {
8699                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8700                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8703                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8704                                 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));
8705                         }
8706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8709                 }
8710                 if (r->driver_path) {
8711                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8712                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8715                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8716                                 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));
8717                         }
8718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8721                 }
8722                 if (r->data_file) {
8723                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8724                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8725                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8726                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8727                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8728                                 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));
8729                         }
8730                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8731                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8732                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8733                 }
8734                 if (r->config_file) {
8735                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8736                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8737                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8738                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8739                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8740                                 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));
8741                         }
8742                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8743                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8744                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8745                 }
8746         }
8747         return NDR_ERR_SUCCESS;
8748 }
8749
8750 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8751 {
8752         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8753         ndr->depth++;
8754         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8755         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8756         ndr->depth++;
8757         if (r->driver_name) {
8758                 ndr_print_string(ndr, "driver_name", r->driver_name);
8759         }
8760         ndr->depth--;
8761         ndr_print_ptr(ndr, "architecture", r->architecture);
8762         ndr->depth++;
8763         if (r->architecture) {
8764                 ndr_print_string(ndr, "architecture", r->architecture);
8765         }
8766         ndr->depth--;
8767         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8768         ndr->depth++;
8769         if (r->driver_path) {
8770                 ndr_print_string(ndr, "driver_path", r->driver_path);
8771         }
8772         ndr->depth--;
8773         ndr_print_ptr(ndr, "data_file", r->data_file);
8774         ndr->depth++;
8775         if (r->data_file) {
8776                 ndr_print_string(ndr, "data_file", r->data_file);
8777         }
8778         ndr->depth--;
8779         ndr_print_ptr(ndr, "config_file", r->config_file);
8780         ndr->depth++;
8781         if (r->config_file) {
8782                 ndr_print_string(ndr, "config_file", r->config_file);
8783         }
8784         ndr->depth--;
8785         ndr->depth--;
8786 }
8787
8788 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8789 {
8790         if (ndr_flags & NDR_SCALARS) {
8791                 NDR_CHECK(ndr_push_align(ndr, 5));
8792                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8803                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8804         }
8805         if (ndr_flags & NDR_BUFFERS) {
8806                 if (r->driver_name) {
8807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8810                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8811                 }
8812                 if (r->architecture) {
8813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8816                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8817                 }
8818                 if (r->driver_path) {
8819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8822                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8823                 }
8824                 if (r->data_file) {
8825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8828                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8829                 }
8830                 if (r->config_file) {
8831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8834                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8835                 }
8836                 if (r->help_file) {
8837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8840                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8841                 }
8842                 if (r->monitor_name) {
8843                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8846                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8847                 }
8848                 if (r->default_datatype) {
8849                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8852                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8853                 }
8854                 if (r->dependent_files) {
8855                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8856                 }
8857         }
8858         return NDR_ERR_SUCCESS;
8859 }
8860
8861 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8862 {
8863         uint32_t _ptr_driver_name;
8864         TALLOC_CTX *_mem_save_driver_name_0;
8865         uint32_t _ptr_architecture;
8866         TALLOC_CTX *_mem_save_architecture_0;
8867         uint32_t _ptr_driver_path;
8868         TALLOC_CTX *_mem_save_driver_path_0;
8869         uint32_t _ptr_data_file;
8870         TALLOC_CTX *_mem_save_data_file_0;
8871         uint32_t _ptr_config_file;
8872         TALLOC_CTX *_mem_save_config_file_0;
8873         uint32_t _ptr_help_file;
8874         TALLOC_CTX *_mem_save_help_file_0;
8875         uint32_t _ptr_monitor_name;
8876         TALLOC_CTX *_mem_save_monitor_name_0;
8877         uint32_t _ptr_default_datatype;
8878         TALLOC_CTX *_mem_save_default_datatype_0;
8879         uint32_t _ptr_dependent_files;
8880         TALLOC_CTX *_mem_save_dependent_files_0;
8881         if (ndr_flags & NDR_SCALARS) {
8882                 NDR_CHECK(ndr_pull_align(ndr, 5));
8883                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8885                 if (_ptr_driver_name) {
8886                         NDR_PULL_ALLOC(ndr, r->driver_name);
8887                 } else {
8888                         r->driver_name = NULL;
8889                 }
8890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8891                 if (_ptr_architecture) {
8892                         NDR_PULL_ALLOC(ndr, r->architecture);
8893                 } else {
8894                         r->architecture = NULL;
8895                 }
8896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8897                 if (_ptr_driver_path) {
8898                         NDR_PULL_ALLOC(ndr, r->driver_path);
8899                 } else {
8900                         r->driver_path = NULL;
8901                 }
8902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8903                 if (_ptr_data_file) {
8904                         NDR_PULL_ALLOC(ndr, r->data_file);
8905                 } else {
8906                         r->data_file = NULL;
8907                 }
8908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8909                 if (_ptr_config_file) {
8910                         NDR_PULL_ALLOC(ndr, r->config_file);
8911                 } else {
8912                         r->config_file = NULL;
8913                 }
8914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8915                 if (_ptr_help_file) {
8916                         NDR_PULL_ALLOC(ndr, r->help_file);
8917                 } else {
8918                         r->help_file = NULL;
8919                 }
8920                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8921                 if (_ptr_monitor_name) {
8922                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8923                 } else {
8924                         r->monitor_name = NULL;
8925                 }
8926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8927                 if (_ptr_default_datatype) {
8928                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8929                 } else {
8930                         r->default_datatype = NULL;
8931                 }
8932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8934                 if (_ptr_dependent_files) {
8935                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8936                 } else {
8937                         r->dependent_files = NULL;
8938                 }
8939                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8940         }
8941         if (ndr_flags & NDR_BUFFERS) {
8942                 if (r->driver_name) {
8943                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8944                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8947                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8948                                 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));
8949                         }
8950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8953                 }
8954                 if (r->architecture) {
8955                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8956                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8959                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8960                                 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));
8961                         }
8962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8965                 }
8966                 if (r->driver_path) {
8967                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8968                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8969                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8970                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8971                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8972                                 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));
8973                         }
8974                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8975                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8976                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8977                 }
8978                 if (r->data_file) {
8979                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8980                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8981                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8982                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8983                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8984                                 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));
8985                         }
8986                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8987                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8989                 }
8990                 if (r->config_file) {
8991                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8992                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8993                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8994                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8995                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8996                                 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));
8997                         }
8998                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8999                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9000                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9001                 }
9002                 if (r->help_file) {
9003                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9004                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9005                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9006                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9007                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9008                                 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));
9009                         }
9010                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9011                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9013                 }
9014                 if (r->monitor_name) {
9015                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9016                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9017                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9018                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9019                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9020                                 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));
9021                         }
9022                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9023                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9024                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9025                 }
9026                 if (r->default_datatype) {
9027                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9028                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9029                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9030                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9031                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9032                                 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));
9033                         }
9034                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9035                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9036                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9037                 }
9038                 if (r->dependent_files) {
9039                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9040                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9041                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9043                 }
9044         }
9045         return NDR_ERR_SUCCESS;
9046 }
9047
9048 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
9049 {
9050         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
9051         ndr->depth++;
9052         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9053         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9054         ndr->depth++;
9055         if (r->driver_name) {
9056                 ndr_print_string(ndr, "driver_name", r->driver_name);
9057         }
9058         ndr->depth--;
9059         ndr_print_ptr(ndr, "architecture", r->architecture);
9060         ndr->depth++;
9061         if (r->architecture) {
9062                 ndr_print_string(ndr, "architecture", r->architecture);
9063         }
9064         ndr->depth--;
9065         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9066         ndr->depth++;
9067         if (r->driver_path) {
9068                 ndr_print_string(ndr, "driver_path", r->driver_path);
9069         }
9070         ndr->depth--;
9071         ndr_print_ptr(ndr, "data_file", r->data_file);
9072         ndr->depth++;
9073         if (r->data_file) {
9074                 ndr_print_string(ndr, "data_file", r->data_file);
9075         }
9076         ndr->depth--;
9077         ndr_print_ptr(ndr, "config_file", r->config_file);
9078         ndr->depth++;
9079         if (r->config_file) {
9080                 ndr_print_string(ndr, "config_file", r->config_file);
9081         }
9082         ndr->depth--;
9083         ndr_print_ptr(ndr, "help_file", r->help_file);
9084         ndr->depth++;
9085         if (r->help_file) {
9086                 ndr_print_string(ndr, "help_file", r->help_file);
9087         }
9088         ndr->depth--;
9089         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9090         ndr->depth++;
9091         if (r->monitor_name) {
9092                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9093         }
9094         ndr->depth--;
9095         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9096         ndr->depth++;
9097         if (r->default_datatype) {
9098                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9099         }
9100         ndr->depth--;
9101         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);
9102         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9103         ndr->depth++;
9104         if (r->dependent_files) {
9105                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9106         }
9107         ndr->depth--;
9108         ndr->depth--;
9109 }
9110
9111 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
9112 {
9113         if (ndr_flags & NDR_SCALARS) {
9114                 NDR_CHECK(ndr_push_align(ndr, 5));
9115                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9128                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9129         }
9130         if (ndr_flags & NDR_BUFFERS) {
9131                 if (r->driver_name) {
9132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9135                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9136                 }
9137                 if (r->architecture) {
9138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9142                 }
9143                 if (r->driver_path) {
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9148                 }
9149                 if (r->data_file) {
9150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9154                 }
9155                 if (r->config_file) {
9156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9158                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9160                 }
9161                 if (r->help_file) {
9162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9166                 }
9167                 if (r->monitor_name) {
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9171                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9172                 }
9173                 if (r->default_datatype) {
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9178                 }
9179                 if (r->dependent_files) {
9180                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9181                 }
9182                 if (r->previous_names) {
9183                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9184                 }
9185         }
9186         return NDR_ERR_SUCCESS;
9187 }
9188
9189 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
9190 {
9191         uint32_t _ptr_driver_name;
9192         TALLOC_CTX *_mem_save_driver_name_0;
9193         uint32_t _ptr_architecture;
9194         TALLOC_CTX *_mem_save_architecture_0;
9195         uint32_t _ptr_driver_path;
9196         TALLOC_CTX *_mem_save_driver_path_0;
9197         uint32_t _ptr_data_file;
9198         TALLOC_CTX *_mem_save_data_file_0;
9199         uint32_t _ptr_config_file;
9200         TALLOC_CTX *_mem_save_config_file_0;
9201         uint32_t _ptr_help_file;
9202         TALLOC_CTX *_mem_save_help_file_0;
9203         uint32_t _ptr_monitor_name;
9204         TALLOC_CTX *_mem_save_monitor_name_0;
9205         uint32_t _ptr_default_datatype;
9206         TALLOC_CTX *_mem_save_default_datatype_0;
9207         uint32_t _ptr_dependent_files;
9208         TALLOC_CTX *_mem_save_dependent_files_0;
9209         uint32_t _ptr_previous_names;
9210         TALLOC_CTX *_mem_save_previous_names_0;
9211         if (ndr_flags & NDR_SCALARS) {
9212                 NDR_CHECK(ndr_pull_align(ndr, 5));
9213                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9215                 if (_ptr_driver_name) {
9216                         NDR_PULL_ALLOC(ndr, r->driver_name);
9217                 } else {
9218                         r->driver_name = NULL;
9219                 }
9220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9221                 if (_ptr_architecture) {
9222                         NDR_PULL_ALLOC(ndr, r->architecture);
9223                 } else {
9224                         r->architecture = NULL;
9225                 }
9226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9227                 if (_ptr_driver_path) {
9228                         NDR_PULL_ALLOC(ndr, r->driver_path);
9229                 } else {
9230                         r->driver_path = NULL;
9231                 }
9232                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9233                 if (_ptr_data_file) {
9234                         NDR_PULL_ALLOC(ndr, r->data_file);
9235                 } else {
9236                         r->data_file = NULL;
9237                 }
9238                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9239                 if (_ptr_config_file) {
9240                         NDR_PULL_ALLOC(ndr, r->config_file);
9241                 } else {
9242                         r->config_file = NULL;
9243                 }
9244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9245                 if (_ptr_help_file) {
9246                         NDR_PULL_ALLOC(ndr, r->help_file);
9247                 } else {
9248                         r->help_file = NULL;
9249                 }
9250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9251                 if (_ptr_monitor_name) {
9252                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9253                 } else {
9254                         r->monitor_name = NULL;
9255                 }
9256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9257                 if (_ptr_default_datatype) {
9258                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9259                 } else {
9260                         r->default_datatype = NULL;
9261                 }
9262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9264                 if (_ptr_dependent_files) {
9265                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9266                 } else {
9267                         r->dependent_files = NULL;
9268                 }
9269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9271                 if (_ptr_previous_names) {
9272                         NDR_PULL_ALLOC(ndr, r->previous_names);
9273                 } else {
9274                         r->previous_names = NULL;
9275                 }
9276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9277         }
9278         if (ndr_flags & NDR_BUFFERS) {
9279                 if (r->driver_name) {
9280                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9281                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9283                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9284                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9285                                 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));
9286                         }
9287                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9288                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9290                 }
9291                 if (r->architecture) {
9292                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9293                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9295                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9296                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9297                                 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));
9298                         }
9299                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9300                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9302                 }
9303                 if (r->driver_path) {
9304                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9305                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9306                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9307                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9308                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9309                                 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));
9310                         }
9311                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9312                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9313                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9314                 }
9315                 if (r->data_file) {
9316                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9317                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9318                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9319                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9320                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9321                                 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));
9322                         }
9323                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9324                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9325                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9326                 }
9327                 if (r->config_file) {
9328                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9329                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9330                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9331                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9332                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9333                                 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));
9334                         }
9335                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9336                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9338                 }
9339                 if (r->help_file) {
9340                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9341                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9342                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9343                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9344                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9345                                 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));
9346                         }
9347                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9348                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9349                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9350                 }
9351                 if (r->monitor_name) {
9352                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9353                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9356                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9357                                 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));
9358                         }
9359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9362                 }
9363                 if (r->default_datatype) {
9364                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9365                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9368                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9369                                 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));
9370                         }
9371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9374                 }
9375                 if (r->dependent_files) {
9376                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9377                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9378                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9380                 }
9381                 if (r->previous_names) {
9382                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9383                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9384                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9386                 }
9387         }
9388         return NDR_ERR_SUCCESS;
9389 }
9390
9391 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9392 {
9393         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9394         ndr->depth++;
9395         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9396         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9397         ndr->depth++;
9398         if (r->driver_name) {
9399                 ndr_print_string(ndr, "driver_name", r->driver_name);
9400         }
9401         ndr->depth--;
9402         ndr_print_ptr(ndr, "architecture", r->architecture);
9403         ndr->depth++;
9404         if (r->architecture) {
9405                 ndr_print_string(ndr, "architecture", r->architecture);
9406         }
9407         ndr->depth--;
9408         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9409         ndr->depth++;
9410         if (r->driver_path) {
9411                 ndr_print_string(ndr, "driver_path", r->driver_path);
9412         }
9413         ndr->depth--;
9414         ndr_print_ptr(ndr, "data_file", r->data_file);
9415         ndr->depth++;
9416         if (r->data_file) {
9417                 ndr_print_string(ndr, "data_file", r->data_file);
9418         }
9419         ndr->depth--;
9420         ndr_print_ptr(ndr, "config_file", r->config_file);
9421         ndr->depth++;
9422         if (r->config_file) {
9423                 ndr_print_string(ndr, "config_file", r->config_file);
9424         }
9425         ndr->depth--;
9426         ndr_print_ptr(ndr, "help_file", r->help_file);
9427         ndr->depth++;
9428         if (r->help_file) {
9429                 ndr_print_string(ndr, "help_file", r->help_file);
9430         }
9431         ndr->depth--;
9432         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9433         ndr->depth++;
9434         if (r->monitor_name) {
9435                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9436         }
9437         ndr->depth--;
9438         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9439         ndr->depth++;
9440         if (r->default_datatype) {
9441                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9442         }
9443         ndr->depth--;
9444         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);
9445         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9446         ndr->depth++;
9447         if (r->dependent_files) {
9448                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9449         }
9450         ndr->depth--;
9451         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);
9452         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9453         ndr->depth++;
9454         if (r->previous_names) {
9455                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9456         }
9457         ndr->depth--;
9458         ndr->depth--;
9459 }
9460
9461 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9462 {
9463         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9464         return NDR_ERR_SUCCESS;
9465 }
9466
9467 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9468 {
9469         uint32_t v;
9470         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9471         *r = v;
9472         return NDR_ERR_SUCCESS;
9473 }
9474
9475 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9476 {
9477         ndr_print_uint32(ndr, name, r);
9478         ndr->depth++;
9479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9480         ndr->depth--;
9481 }
9482
9483 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9484 {
9485         if (ndr_flags & NDR_SCALARS) {
9486                 NDR_CHECK(ndr_push_align(ndr, 8));
9487                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9490                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9497                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9500                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9501                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9503                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9505                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9506                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9507         }
9508         if (ndr_flags & NDR_BUFFERS) {
9509                 if (r->driver_name) {
9510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9513                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9514                 }
9515                 if (r->architecture) {
9516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9518                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9519                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9520                 }
9521                 if (r->driver_path) {
9522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9525                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9526                 }
9527                 if (r->data_file) {
9528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9531                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9532                 }
9533                 if (r->config_file) {
9534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9538                 }
9539                 if (r->help_file) {
9540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9543                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9544                 }
9545                 if (r->monitor_name) {
9546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9548                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9550                 }
9551                 if (r->default_datatype) {
9552                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9553                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9554                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9556                 }
9557                 if (r->dependent_files) {
9558                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9559                 }
9560                 if (r->previous_names) {
9561                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9562                 }
9563                 if (r->manufacturer_name) {
9564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9565                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9567                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9568                 }
9569                 if (r->manufacturer_url) {
9570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9571                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9574                 }
9575                 if (r->hardware_id) {
9576                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9577                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9579                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9580                 }
9581                 if (r->provider) {
9582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9583                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9584                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9585                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9586                 }
9587         }
9588         return NDR_ERR_SUCCESS;
9589 }
9590
9591 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9592 {
9593         uint32_t _ptr_driver_name;
9594         TALLOC_CTX *_mem_save_driver_name_0;
9595         uint32_t _ptr_architecture;
9596         TALLOC_CTX *_mem_save_architecture_0;
9597         uint32_t _ptr_driver_path;
9598         TALLOC_CTX *_mem_save_driver_path_0;
9599         uint32_t _ptr_data_file;
9600         TALLOC_CTX *_mem_save_data_file_0;
9601         uint32_t _ptr_config_file;
9602         TALLOC_CTX *_mem_save_config_file_0;
9603         uint32_t _ptr_help_file;
9604         TALLOC_CTX *_mem_save_help_file_0;
9605         uint32_t _ptr_monitor_name;
9606         TALLOC_CTX *_mem_save_monitor_name_0;
9607         uint32_t _ptr_default_datatype;
9608         TALLOC_CTX *_mem_save_default_datatype_0;
9609         uint32_t _ptr_dependent_files;
9610         TALLOC_CTX *_mem_save_dependent_files_0;
9611         uint32_t _ptr_previous_names;
9612         TALLOC_CTX *_mem_save_previous_names_0;
9613         uint32_t _ptr_manufacturer_name;
9614         TALLOC_CTX *_mem_save_manufacturer_name_0;
9615         uint32_t _ptr_manufacturer_url;
9616         TALLOC_CTX *_mem_save_manufacturer_url_0;
9617         uint32_t _ptr_hardware_id;
9618         TALLOC_CTX *_mem_save_hardware_id_0;
9619         uint32_t _ptr_provider;
9620         TALLOC_CTX *_mem_save_provider_0;
9621         if (ndr_flags & NDR_SCALARS) {
9622                 NDR_CHECK(ndr_pull_align(ndr, 8));
9623                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9625                 if (_ptr_driver_name) {
9626                         NDR_PULL_ALLOC(ndr, r->driver_name);
9627                 } else {
9628                         r->driver_name = NULL;
9629                 }
9630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9631                 if (_ptr_architecture) {
9632                         NDR_PULL_ALLOC(ndr, r->architecture);
9633                 } else {
9634                         r->architecture = NULL;
9635                 }
9636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9637                 if (_ptr_driver_path) {
9638                         NDR_PULL_ALLOC(ndr, r->driver_path);
9639                 } else {
9640                         r->driver_path = NULL;
9641                 }
9642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9643                 if (_ptr_data_file) {
9644                         NDR_PULL_ALLOC(ndr, r->data_file);
9645                 } else {
9646                         r->data_file = NULL;
9647                 }
9648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9649                 if (_ptr_config_file) {
9650                         NDR_PULL_ALLOC(ndr, r->config_file);
9651                 } else {
9652                         r->config_file = NULL;
9653                 }
9654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9655                 if (_ptr_help_file) {
9656                         NDR_PULL_ALLOC(ndr, r->help_file);
9657                 } else {
9658                         r->help_file = NULL;
9659                 }
9660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9661                 if (_ptr_monitor_name) {
9662                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9663                 } else {
9664                         r->monitor_name = NULL;
9665                 }
9666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9667                 if (_ptr_default_datatype) {
9668                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9669                 } else {
9670                         r->default_datatype = NULL;
9671                 }
9672                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9673                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9674                 if (_ptr_dependent_files) {
9675                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9676                 } else {
9677                         r->dependent_files = NULL;
9678                 }
9679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9681                 if (_ptr_previous_names) {
9682                         NDR_PULL_ALLOC(ndr, r->previous_names);
9683                 } else {
9684                         r->previous_names = NULL;
9685                 }
9686                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9687                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9689                 if (_ptr_manufacturer_name) {
9690                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9691                 } else {
9692                         r->manufacturer_name = NULL;
9693                 }
9694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9695                 if (_ptr_manufacturer_url) {
9696                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9697                 } else {
9698                         r->manufacturer_url = NULL;
9699                 }
9700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9701                 if (_ptr_hardware_id) {
9702                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9703                 } else {
9704                         r->hardware_id = NULL;
9705                 }
9706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9707                 if (_ptr_provider) {
9708                         NDR_PULL_ALLOC(ndr, r->provider);
9709                 } else {
9710                         r->provider = NULL;
9711                 }
9712                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9713         }
9714         if (ndr_flags & NDR_BUFFERS) {
9715                 if (r->driver_name) {
9716                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9717                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9718                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9719                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9720                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9721                                 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));
9722                         }
9723                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9726                 }
9727                 if (r->architecture) {
9728                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9729                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9732                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9733                                 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));
9734                         }
9735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9738                 }
9739                 if (r->driver_path) {
9740                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9741                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9744                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9745                                 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));
9746                         }
9747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9750                 }
9751                 if (r->data_file) {
9752                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9753                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9754                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9755                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9756                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9757                                 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));
9758                         }
9759                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9760                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9762                 }
9763                 if (r->config_file) {
9764                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9765                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9766                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9767                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9768                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9769                                 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));
9770                         }
9771                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9772                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9774                 }
9775                 if (r->help_file) {
9776                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9777                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9780                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9781                                 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));
9782                         }
9783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9786                 }
9787                 if (r->monitor_name) {
9788                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9789                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9792                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9793                                 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));
9794                         }
9795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9798                 }
9799                 if (r->default_datatype) {
9800                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9801                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9802                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9803                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9804                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9805                                 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));
9806                         }
9807                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9808                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9809                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9810                 }
9811                 if (r->dependent_files) {
9812                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9813                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9814                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9816                 }
9817                 if (r->previous_names) {
9818                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9819                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9820                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9822                 }
9823                 if (r->manufacturer_name) {
9824                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9825                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9828                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9829                                 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));
9830                         }
9831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9834                 }
9835                 if (r->manufacturer_url) {
9836                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9837                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9838                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9839                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9840                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9841                                 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));
9842                         }
9843                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9844                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9846                 }
9847                 if (r->hardware_id) {
9848                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9849                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9850                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9851                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9852                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9853                                 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));
9854                         }
9855                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9856                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9858                 }
9859                 if (r->provider) {
9860                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9861                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9862                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9863                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9864                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9865                                 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));
9866                         }
9867                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9868                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9870                 }
9871         }
9872         return NDR_ERR_SUCCESS;
9873 }
9874
9875 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9876 {
9877         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9878         ndr->depth++;
9879         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9880         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9881         ndr->depth++;
9882         if (r->driver_name) {
9883                 ndr_print_string(ndr, "driver_name", r->driver_name);
9884         }
9885         ndr->depth--;
9886         ndr_print_ptr(ndr, "architecture", r->architecture);
9887         ndr->depth++;
9888         if (r->architecture) {
9889                 ndr_print_string(ndr, "architecture", r->architecture);
9890         }
9891         ndr->depth--;
9892         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9893         ndr->depth++;
9894         if (r->driver_path) {
9895                 ndr_print_string(ndr, "driver_path", r->driver_path);
9896         }
9897         ndr->depth--;
9898         ndr_print_ptr(ndr, "data_file", r->data_file);
9899         ndr->depth++;
9900         if (r->data_file) {
9901                 ndr_print_string(ndr, "data_file", r->data_file);
9902         }
9903         ndr->depth--;
9904         ndr_print_ptr(ndr, "config_file", r->config_file);
9905         ndr->depth++;
9906         if (r->config_file) {
9907                 ndr_print_string(ndr, "config_file", r->config_file);
9908         }
9909         ndr->depth--;
9910         ndr_print_ptr(ndr, "help_file", r->help_file);
9911         ndr->depth++;
9912         if (r->help_file) {
9913                 ndr_print_string(ndr, "help_file", r->help_file);
9914         }
9915         ndr->depth--;
9916         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9917         ndr->depth++;
9918         if (r->monitor_name) {
9919                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9920         }
9921         ndr->depth--;
9922         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9923         ndr->depth++;
9924         if (r->default_datatype) {
9925                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9926         }
9927         ndr->depth--;
9928         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);
9929         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9930         ndr->depth++;
9931         if (r->dependent_files) {
9932                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9933         }
9934         ndr->depth--;
9935         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);
9936         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9937         ndr->depth++;
9938         if (r->previous_names) {
9939                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9940         }
9941         ndr->depth--;
9942         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9943         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9944         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9945         ndr->depth++;
9946         if (r->manufacturer_name) {
9947                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9948         }
9949         ndr->depth--;
9950         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9951         ndr->depth++;
9952         if (r->manufacturer_url) {
9953                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9954         }
9955         ndr->depth--;
9956         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9957         ndr->depth++;
9958         if (r->hardware_id) {
9959                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9960         }
9961         ndr->depth--;
9962         ndr_print_ptr(ndr, "provider", r->provider);
9963         ndr->depth++;
9964         if (r->provider) {
9965                 ndr_print_string(ndr, "provider", r->provider);
9966         }
9967         ndr->depth--;
9968         ndr->depth--;
9969 }
9970
9971 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9972 {
9973         if (ndr_flags & NDR_SCALARS) {
9974                 NDR_CHECK(ndr_push_align(ndr, 8));
9975                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9979                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9981                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9982                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9988                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9989                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9990                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
10000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
10001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
10002                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
10003                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
10004                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10005         }
10006         if (ndr_flags & NDR_BUFFERS) {
10007                 if (r->driver_name) {
10008                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
10009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10010                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
10011                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10012                 }
10013                 if (r->architecture) {
10014                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
10015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
10017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10018                 }
10019                 if (r->driver_path) {
10020                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
10021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
10023                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10024                 }
10025                 if (r->data_file) {
10026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
10027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10028                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
10029                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10030                 }
10031                 if (r->config_file) {
10032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
10033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
10035                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10036                 }
10037                 if (r->help_file) {
10038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
10039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
10041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10042                 }
10043                 if (r->monitor_name) {
10044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
10045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
10047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10048                 }
10049                 if (r->default_datatype) {
10050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
10051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
10053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10054                 }
10055                 if (r->dependent_files) {
10056                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10057                 }
10058                 if (r->previous_names) {
10059                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10060                 }
10061                 if (r->manufacturer_name) {
10062                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
10063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
10065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10066                 }
10067                 if (r->manufacturer_url) {
10068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
10069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
10071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10072                 }
10073                 if (r->hardware_id) {
10074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
10075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
10077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10078                 }
10079                 if (r->provider) {
10080                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
10081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
10083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10084                 }
10085                 if (r->print_processor) {
10086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
10087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
10089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10090                 }
10091                 if (r->vendor_setup) {
10092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
10093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
10095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10096                 }
10097                 if (r->color_profiles) {
10098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10099                 }
10100                 if (r->inf_path) {
10101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
10102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
10104                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10105                 }
10106                 if (r->core_driver_dependencies) {
10107                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10108                 }
10109         }
10110         return NDR_ERR_SUCCESS;
10111 }
10112
10113 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
10114 {
10115         uint32_t _ptr_driver_name;
10116         TALLOC_CTX *_mem_save_driver_name_0;
10117         uint32_t _ptr_architecture;
10118         TALLOC_CTX *_mem_save_architecture_0;
10119         uint32_t _ptr_driver_path;
10120         TALLOC_CTX *_mem_save_driver_path_0;
10121         uint32_t _ptr_data_file;
10122         TALLOC_CTX *_mem_save_data_file_0;
10123         uint32_t _ptr_config_file;
10124         TALLOC_CTX *_mem_save_config_file_0;
10125         uint32_t _ptr_help_file;
10126         TALLOC_CTX *_mem_save_help_file_0;
10127         uint32_t _ptr_monitor_name;
10128         TALLOC_CTX *_mem_save_monitor_name_0;
10129         uint32_t _ptr_default_datatype;
10130         TALLOC_CTX *_mem_save_default_datatype_0;
10131         uint32_t _ptr_dependent_files;
10132         TALLOC_CTX *_mem_save_dependent_files_0;
10133         uint32_t _ptr_previous_names;
10134         TALLOC_CTX *_mem_save_previous_names_0;
10135         uint32_t _ptr_manufacturer_name;
10136         TALLOC_CTX *_mem_save_manufacturer_name_0;
10137         uint32_t _ptr_manufacturer_url;
10138         TALLOC_CTX *_mem_save_manufacturer_url_0;
10139         uint32_t _ptr_hardware_id;
10140         TALLOC_CTX *_mem_save_hardware_id_0;
10141         uint32_t _ptr_provider;
10142         TALLOC_CTX *_mem_save_provider_0;
10143         uint32_t _ptr_print_processor;
10144         TALLOC_CTX *_mem_save_print_processor_0;
10145         uint32_t _ptr_vendor_setup;
10146         TALLOC_CTX *_mem_save_vendor_setup_0;
10147         uint32_t _ptr_color_profiles;
10148         TALLOC_CTX *_mem_save_color_profiles_0;
10149         uint32_t _ptr_inf_path;
10150         TALLOC_CTX *_mem_save_inf_path_0;
10151         uint32_t _ptr_core_driver_dependencies;
10152         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
10153         if (ndr_flags & NDR_SCALARS) {
10154                 NDR_CHECK(ndr_pull_align(ndr, 8));
10155                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10157                 if (_ptr_driver_name) {
10158                         NDR_PULL_ALLOC(ndr, r->driver_name);
10159                 } else {
10160                         r->driver_name = NULL;
10161                 }
10162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10163                 if (_ptr_architecture) {
10164                         NDR_PULL_ALLOC(ndr, r->architecture);
10165                 } else {
10166                         r->architecture = NULL;
10167                 }
10168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10169                 if (_ptr_driver_path) {
10170                         NDR_PULL_ALLOC(ndr, r->driver_path);
10171                 } else {
10172                         r->driver_path = NULL;
10173                 }
10174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10175                 if (_ptr_data_file) {
10176                         NDR_PULL_ALLOC(ndr, r->data_file);
10177                 } else {
10178                         r->data_file = NULL;
10179                 }
10180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10181                 if (_ptr_config_file) {
10182                         NDR_PULL_ALLOC(ndr, r->config_file);
10183                 } else {
10184                         r->config_file = NULL;
10185                 }
10186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10187                 if (_ptr_help_file) {
10188                         NDR_PULL_ALLOC(ndr, r->help_file);
10189                 } else {
10190                         r->help_file = NULL;
10191                 }
10192                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10193                 if (_ptr_monitor_name) {
10194                         NDR_PULL_ALLOC(ndr, r->monitor_name);
10195                 } else {
10196                         r->monitor_name = NULL;
10197                 }
10198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10199                 if (_ptr_default_datatype) {
10200                         NDR_PULL_ALLOC(ndr, r->default_datatype);
10201                 } else {
10202                         r->default_datatype = NULL;
10203                 }
10204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
10205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10206                 if (_ptr_dependent_files) {
10207                         NDR_PULL_ALLOC(ndr, r->dependent_files);
10208                 } else {
10209                         r->dependent_files = NULL;
10210                 }
10211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
10212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10213                 if (_ptr_previous_names) {
10214                         NDR_PULL_ALLOC(ndr, r->previous_names);
10215                 } else {
10216                         r->previous_names = NULL;
10217                 }
10218                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10219                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10221                 if (_ptr_manufacturer_name) {
10222                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10223                 } else {
10224                         r->manufacturer_name = NULL;
10225                 }
10226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10227                 if (_ptr_manufacturer_url) {
10228                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10229                 } else {
10230                         r->manufacturer_url = NULL;
10231                 }
10232                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10233                 if (_ptr_hardware_id) {
10234                         NDR_PULL_ALLOC(ndr, r->hardware_id);
10235                 } else {
10236                         r->hardware_id = NULL;
10237                 }
10238                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10239                 if (_ptr_provider) {
10240                         NDR_PULL_ALLOC(ndr, r->provider);
10241                 } else {
10242                         r->provider = NULL;
10243                 }
10244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
10245                 if (_ptr_print_processor) {
10246                         NDR_PULL_ALLOC(ndr, r->print_processor);
10247                 } else {
10248                         r->print_processor = NULL;
10249                 }
10250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
10251                 if (_ptr_vendor_setup) {
10252                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
10253                 } else {
10254                         r->vendor_setup = NULL;
10255                 }
10256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
10257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
10258                 if (_ptr_color_profiles) {
10259                         NDR_PULL_ALLOC(ndr, r->color_profiles);
10260                 } else {
10261                         r->color_profiles = NULL;
10262                 }
10263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
10264                 if (_ptr_inf_path) {
10265                         NDR_PULL_ALLOC(ndr, r->inf_path);
10266                 } else {
10267                         r->inf_path = NULL;
10268                 }
10269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
10270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
10271                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
10272                 if (_ptr_core_driver_dependencies) {
10273                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
10274                 } else {
10275                         r->core_driver_dependencies = NULL;
10276                 }
10277                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
10278                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
10279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10280         }
10281         if (ndr_flags & NDR_BUFFERS) {
10282                 if (r->driver_name) {
10283                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10284                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
10286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
10287                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
10288                                 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));
10289                         }
10290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
10291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
10292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10293                 }
10294                 if (r->architecture) {
10295                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10296                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
10298                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
10299                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
10300                                 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));
10301                         }
10302                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
10303                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
10304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10305                 }
10306                 if (r->driver_path) {
10307                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10308                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
10310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
10311                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
10312                                 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));
10313                         }
10314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
10315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
10316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10317                 }
10318                 if (r->data_file) {
10319                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10320                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
10322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
10323                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
10324                                 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));
10325                         }
10326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
10327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
10328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10329                 }
10330                 if (r->config_file) {
10331                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10332                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
10334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
10335                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
10336                                 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));
10337                         }
10338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
10339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
10340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10341                 }
10342                 if (r->help_file) {
10343                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10344                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
10346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
10347                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
10348                                 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));
10349                         }
10350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
10351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
10352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10353                 }
10354                 if (r->monitor_name) {
10355                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10356                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
10358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
10359                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
10360                                 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));
10361                         }
10362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
10363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
10364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10365                 }
10366                 if (r->default_datatype) {
10367                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10368                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10369                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
10370                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
10371                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10372                                 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));
10373                         }
10374                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10375                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10377                 }
10378                 if (r->dependent_files) {
10379                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10380                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10381                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10383                 }
10384                 if (r->previous_names) {
10385                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10386                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10387                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10388                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10389                 }
10390                 if (r->manufacturer_name) {
10391                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10392                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10393                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10394                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10395                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10396                                 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));
10397                         }
10398                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10399                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10401                 }
10402                 if (r->manufacturer_url) {
10403                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10404                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10405                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10406                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10407                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10408                                 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));
10409                         }
10410                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10411                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10413                 }
10414                 if (r->hardware_id) {
10415                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10416                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10417                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10418                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10419                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10420                                 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));
10421                         }
10422                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10423                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10425                 }
10426                 if (r->provider) {
10427                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10428                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10430                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10431                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10432                                 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));
10433                         }
10434                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10435                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10437                 }
10438                 if (r->print_processor) {
10439                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10440                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10442                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10443                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10444                                 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));
10445                         }
10446                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10447                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10449                 }
10450                 if (r->vendor_setup) {
10451                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10452                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10455                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10456                                 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));
10457                         }
10458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10459                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10461                 }
10462                 if (r->color_profiles) {
10463                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10464                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10465                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10467                 }
10468                 if (r->inf_path) {
10469                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10470                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10471                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10472                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10473                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10474                                 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));
10475                         }
10476                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10477                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10479                 }
10480                 if (r->core_driver_dependencies) {
10481                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10482                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10483                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10485                 }
10486         }
10487         return NDR_ERR_SUCCESS;
10488 }
10489
10490 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10491 {
10492         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10493         ndr->depth++;
10494         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10495         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10496         ndr->depth++;
10497         if (r->driver_name) {
10498                 ndr_print_string(ndr, "driver_name", r->driver_name);
10499         }
10500         ndr->depth--;
10501         ndr_print_ptr(ndr, "architecture", r->architecture);
10502         ndr->depth++;
10503         if (r->architecture) {
10504                 ndr_print_string(ndr, "architecture", r->architecture);
10505         }
10506         ndr->depth--;
10507         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10508         ndr->depth++;
10509         if (r->driver_path) {
10510                 ndr_print_string(ndr, "driver_path", r->driver_path);
10511         }
10512         ndr->depth--;
10513         ndr_print_ptr(ndr, "data_file", r->data_file);
10514         ndr->depth++;
10515         if (r->data_file) {
10516                 ndr_print_string(ndr, "data_file", r->data_file);
10517         }
10518         ndr->depth--;
10519         ndr_print_ptr(ndr, "config_file", r->config_file);
10520         ndr->depth++;
10521         if (r->config_file) {
10522                 ndr_print_string(ndr, "config_file", r->config_file);
10523         }
10524         ndr->depth--;
10525         ndr_print_ptr(ndr, "help_file", r->help_file);
10526         ndr->depth++;
10527         if (r->help_file) {
10528                 ndr_print_string(ndr, "help_file", r->help_file);
10529         }
10530         ndr->depth--;
10531         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10532         ndr->depth++;
10533         if (r->monitor_name) {
10534                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10535         }
10536         ndr->depth--;
10537         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10538         ndr->depth++;
10539         if (r->default_datatype) {
10540                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10541         }
10542         ndr->depth--;
10543         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);
10544         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10545         ndr->depth++;
10546         if (r->dependent_files) {
10547                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10548         }
10549         ndr->depth--;
10550         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);
10551         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10552         ndr->depth++;
10553         if (r->previous_names) {
10554                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10555         }
10556         ndr->depth--;
10557         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10558         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10559         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10560         ndr->depth++;
10561         if (r->manufacturer_name) {
10562                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10563         }
10564         ndr->depth--;
10565         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10566         ndr->depth++;
10567         if (r->manufacturer_url) {
10568                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10569         }
10570         ndr->depth--;
10571         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10572         ndr->depth++;
10573         if (r->hardware_id) {
10574                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10575         }
10576         ndr->depth--;
10577         ndr_print_ptr(ndr, "provider", r->provider);
10578         ndr->depth++;
10579         if (r->provider) {
10580                 ndr_print_string(ndr, "provider", r->provider);
10581         }
10582         ndr->depth--;
10583         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10584         ndr->depth++;
10585         if (r->print_processor) {
10586                 ndr_print_string(ndr, "print_processor", r->print_processor);
10587         }
10588         ndr->depth--;
10589         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10590         ndr->depth++;
10591         if (r->vendor_setup) {
10592                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10593         }
10594         ndr->depth--;
10595         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);
10596         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10597         ndr->depth++;
10598         if (r->color_profiles) {
10599                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10600         }
10601         ndr->depth--;
10602         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10603         ndr->depth++;
10604         if (r->inf_path) {
10605                 ndr_print_string(ndr, "inf_path", r->inf_path);
10606         }
10607         ndr->depth--;
10608         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10609         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);
10610         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10611         ndr->depth++;
10612         if (r->core_driver_dependencies) {
10613                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10614         }
10615         ndr->depth--;
10616         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10617         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10618         ndr->depth--;
10619 }
10620
10621 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10622 {
10623         if (ndr_flags & NDR_SCALARS) {
10624                 int level = ndr_push_get_switch_value(ndr, r);
10625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10626                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10627                 switch (level) {
10628                         case 1: {
10629                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10630                         break; }
10631
10632                         case 2: {
10633                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10634                         break; }
10635
10636                         case 3: {
10637                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10638                         break; }
10639
10640                         case 4: {
10641                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10642                         break; }
10643
10644                         case 6: {
10645                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10646                         break; }
10647
10648                         case 8: {
10649                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10650                         break; }
10651
10652                         default:
10653                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10654                 }
10655         }
10656         if (ndr_flags & NDR_BUFFERS) {
10657                 int level = ndr_push_get_switch_value(ndr, r);
10658                 switch (level) {
10659                         case 1:
10660                                 if (r->info1) {
10661                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10662                                 }
10663                         break;
10664
10665                         case 2:
10666                                 if (r->info2) {
10667                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10668                                 }
10669                         break;
10670
10671                         case 3:
10672                                 if (r->info3) {
10673                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10674                                 }
10675                         break;
10676
10677                         case 4:
10678                                 if (r->info4) {
10679                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10680                                 }
10681                         break;
10682
10683                         case 6:
10684                                 if (r->info6) {
10685                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10686                                 }
10687                         break;
10688
10689                         case 8:
10690                                 if (r->info8) {
10691                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10692                                 }
10693                         break;
10694
10695                         default:
10696                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10697                 }
10698         }
10699         return NDR_ERR_SUCCESS;
10700 }
10701
10702 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10703 {
10704         int level;
10705         uint32_t _level;
10706         TALLOC_CTX *_mem_save_info1_0;
10707         TALLOC_CTX *_mem_save_info2_0;
10708         TALLOC_CTX *_mem_save_info3_0;
10709         TALLOC_CTX *_mem_save_info4_0;
10710         TALLOC_CTX *_mem_save_info6_0;
10711         TALLOC_CTX *_mem_save_info8_0;
10712         level = ndr_pull_get_switch_value(ndr, r);
10713         if (ndr_flags & NDR_SCALARS) {
10714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10715                 if (_level != level) {
10716                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10717                 }
10718                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10719                 switch (level) {
10720                         case 1: {
10721                                 uint32_t _ptr_info1;
10722                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10723                                 if (_ptr_info1) {
10724                                         NDR_PULL_ALLOC(ndr, r->info1);
10725                                 } else {
10726                                         r->info1 = NULL;
10727                                 }
10728                         break; }
10729
10730                         case 2: {
10731                                 uint32_t _ptr_info2;
10732                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10733                                 if (_ptr_info2) {
10734                                         NDR_PULL_ALLOC(ndr, r->info2);
10735                                 } else {
10736                                         r->info2 = NULL;
10737                                 }
10738                         break; }
10739
10740                         case 3: {
10741                                 uint32_t _ptr_info3;
10742                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10743                                 if (_ptr_info3) {
10744                                         NDR_PULL_ALLOC(ndr, r->info3);
10745                                 } else {
10746                                         r->info3 = NULL;
10747                                 }
10748                         break; }
10749
10750                         case 4: {
10751                                 uint32_t _ptr_info4;
10752                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10753                                 if (_ptr_info4) {
10754                                         NDR_PULL_ALLOC(ndr, r->info4);
10755                                 } else {
10756                                         r->info4 = NULL;
10757                                 }
10758                         break; }
10759
10760                         case 6: {
10761                                 uint32_t _ptr_info6;
10762                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10763                                 if (_ptr_info6) {
10764                                         NDR_PULL_ALLOC(ndr, r->info6);
10765                                 } else {
10766                                         r->info6 = NULL;
10767                                 }
10768                         break; }
10769
10770                         case 8: {
10771                                 uint32_t _ptr_info8;
10772                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10773                                 if (_ptr_info8) {
10774                                         NDR_PULL_ALLOC(ndr, r->info8);
10775                                 } else {
10776                                         r->info8 = NULL;
10777                                 }
10778                         break; }
10779
10780                         default:
10781                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10782                 }
10783         }
10784         if (ndr_flags & NDR_BUFFERS) {
10785                 switch (level) {
10786                         case 1:
10787                                 if (r->info1) {
10788                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10789                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10790                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10791                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10792                                 }
10793                         break;
10794
10795                         case 2:
10796                                 if (r->info2) {
10797                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10798                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10799                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10800                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10801                                 }
10802                         break;
10803
10804                         case 3:
10805                                 if (r->info3) {
10806                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10807                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10808                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10809                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10810                                 }
10811                         break;
10812
10813                         case 4:
10814                                 if (r->info4) {
10815                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10816                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10817                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10818                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10819                                 }
10820                         break;
10821
10822                         case 6:
10823                                 if (r->info6) {
10824                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10825                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10826                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10827                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10828                                 }
10829                         break;
10830
10831                         case 8:
10832                                 if (r->info8) {
10833                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10834                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10835                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10836                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10837                                 }
10838                         break;
10839
10840                         default:
10841                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10842                 }
10843         }
10844         return NDR_ERR_SUCCESS;
10845 }
10846
10847 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10848 {
10849         int level;
10850         level = ndr_print_get_switch_value(ndr, r);
10851         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10852         switch (level) {
10853                 case 1:
10854                         ndr_print_ptr(ndr, "info1", r->info1);
10855                         ndr->depth++;
10856                         if (r->info1) {
10857                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10858                         }
10859                         ndr->depth--;
10860                 break;
10861
10862                 case 2:
10863                         ndr_print_ptr(ndr, "info2", r->info2);
10864                         ndr->depth++;
10865                         if (r->info2) {
10866                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10867                         }
10868                         ndr->depth--;
10869                 break;
10870
10871                 case 3:
10872                         ndr_print_ptr(ndr, "info3", r->info3);
10873                         ndr->depth++;
10874                         if (r->info3) {
10875                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10876                         }
10877                         ndr->depth--;
10878                 break;
10879
10880                 case 4:
10881                         ndr_print_ptr(ndr, "info4", r->info4);
10882                         ndr->depth++;
10883                         if (r->info4) {
10884                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10885                         }
10886                         ndr->depth--;
10887                 break;
10888
10889                 case 6:
10890                         ndr_print_ptr(ndr, "info6", r->info6);
10891                         ndr->depth++;
10892                         if (r->info6) {
10893                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10894                         }
10895                         ndr->depth--;
10896                 break;
10897
10898                 case 8:
10899                         ndr_print_ptr(ndr, "info8", r->info8);
10900                         ndr->depth++;
10901                         if (r->info8) {
10902                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10903                         }
10904                         ndr->depth--;
10905                 break;
10906
10907                 default:
10908                         ndr_print_bad_level(ndr, name, level);
10909         }
10910 }
10911
10912 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10913 {
10914         if (ndr_flags & NDR_SCALARS) {
10915                 NDR_CHECK(ndr_push_align(ndr, 5));
10916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10917                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10918                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10919                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10920         }
10921         if (ndr_flags & NDR_BUFFERS) {
10922                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10923         }
10924         return NDR_ERR_SUCCESS;
10925 }
10926
10927 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10928 {
10929         if (ndr_flags & NDR_SCALARS) {
10930                 NDR_CHECK(ndr_pull_align(ndr, 5));
10931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10932                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10933                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10934                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10935         }
10936         if (ndr_flags & NDR_BUFFERS) {
10937                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10938         }
10939         return NDR_ERR_SUCCESS;
10940 }
10941
10942 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10943 {
10944         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10945         ndr->depth++;
10946         ndr_print_uint32(ndr, "level", r->level);
10947         ndr_print_set_switch_value(ndr, &r->info, r->level);
10948         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10949         ndr->depth--;
10950 }
10951
10952 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10953 {
10954         if (ndr_flags & NDR_SCALARS) {
10955                 NDR_CHECK(ndr_push_align(ndr, 5));
10956                 {
10957                         uint32_t _flags_save_string = ndr->flags;
10958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10959                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10960                         ndr->flags = _flags_save_string;
10961                 }
10962                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10963         }
10964         if (ndr_flags & NDR_BUFFERS) {
10965                 {
10966                         uint32_t _flags_save_string = ndr->flags;
10967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10968                         if (r->driver_name) {
10969                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
10970                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10971                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
10972                         }
10973                         ndr->flags = _flags_save_string;
10974                 }
10975         }
10976         return NDR_ERR_SUCCESS;
10977 }
10978
10979 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10980 {
10981         uint32_t _ptr_driver_name;
10982         TALLOC_CTX *_mem_save_driver_name_0;
10983         if (ndr_flags & NDR_SCALARS) {
10984                 NDR_CHECK(ndr_pull_align(ndr, 5));
10985                 {
10986                         uint32_t _flags_save_string = ndr->flags;
10987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10988                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10989                         if (_ptr_driver_name) {
10990                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10991                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10992                         } else {
10993                                 r->driver_name = NULL;
10994                         }
10995                         ndr->flags = _flags_save_string;
10996                 }
10997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10998         }
10999         if (ndr_flags & NDR_BUFFERS) {
11000                 {
11001                         uint32_t _flags_save_string = ndr->flags;
11002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11003                         if (r->driver_name) {
11004                                 uint32_t _relative_save_offset;
11005                                 _relative_save_offset = ndr->offset;
11006                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11007                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11008                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11009                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11010                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11011                                 if (ndr->offset > ndr->relative_highest_offset) {
11012                                         ndr->relative_highest_offset = ndr->offset;
11013                                 }
11014                                 ndr->offset = _relative_save_offset;
11015                         }
11016                         ndr->flags = _flags_save_string;
11017                 }
11018         }
11019         return NDR_ERR_SUCCESS;
11020 }
11021
11022 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
11023 {
11024         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
11025         ndr->depth++;
11026         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11027         ndr->depth++;
11028         if (r->driver_name) {
11029                 ndr_print_string(ndr, "driver_name", r->driver_name);
11030         }
11031         ndr->depth--;
11032         ndr->depth--;
11033 }
11034
11035 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
11036 {
11037         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
11038 }
11039
11040 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
11041 {
11042         if (ndr_flags & NDR_SCALARS) {
11043                 NDR_CHECK(ndr_push_align(ndr, 5));
11044                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11045                 {
11046                         uint32_t _flags_save_string = ndr->flags;
11047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11048                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11049                         ndr->flags = _flags_save_string;
11050                 }
11051                 {
11052                         uint32_t _flags_save_string = ndr->flags;
11053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11054                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11055                         ndr->flags = _flags_save_string;
11056                 }
11057                 {
11058                         uint32_t _flags_save_string = ndr->flags;
11059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11060                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11061                         ndr->flags = _flags_save_string;
11062                 }
11063                 {
11064                         uint32_t _flags_save_string = ndr->flags;
11065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11066                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11067                         ndr->flags = _flags_save_string;
11068                 }
11069                 {
11070                         uint32_t _flags_save_string = ndr->flags;
11071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11072                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11073                         ndr->flags = _flags_save_string;
11074                 }
11075                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11076         }
11077         if (ndr_flags & NDR_BUFFERS) {
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         if (r->driver_name) {
11082                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11084                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11085                         }
11086                         ndr->flags = _flags_save_string;
11087                 }
11088                 {
11089                         uint32_t _flags_save_string = ndr->flags;
11090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11091                         if (r->architecture) {
11092                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11094                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11095                         }
11096                         ndr->flags = _flags_save_string;
11097                 }
11098                 {
11099                         uint32_t _flags_save_string = ndr->flags;
11100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11101                         if (r->driver_path) {
11102                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11104                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11105                         }
11106                         ndr->flags = _flags_save_string;
11107                 }
11108                 {
11109                         uint32_t _flags_save_string = ndr->flags;
11110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11111                         if (r->data_file) {
11112                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11113                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11114                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11115                         }
11116                         ndr->flags = _flags_save_string;
11117                 }
11118                 {
11119                         uint32_t _flags_save_string = ndr->flags;
11120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11121                         if (r->config_file) {
11122                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11124                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11125                         }
11126                         ndr->flags = _flags_save_string;
11127                 }
11128         }
11129         return NDR_ERR_SUCCESS;
11130 }
11131
11132 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
11133 {
11134         uint32_t _ptr_driver_name;
11135         TALLOC_CTX *_mem_save_driver_name_0;
11136         uint32_t _ptr_architecture;
11137         TALLOC_CTX *_mem_save_architecture_0;
11138         uint32_t _ptr_driver_path;
11139         TALLOC_CTX *_mem_save_driver_path_0;
11140         uint32_t _ptr_data_file;
11141         TALLOC_CTX *_mem_save_data_file_0;
11142         uint32_t _ptr_config_file;
11143         TALLOC_CTX *_mem_save_config_file_0;
11144         if (ndr_flags & NDR_SCALARS) {
11145                 NDR_CHECK(ndr_pull_align(ndr, 5));
11146                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11147                 {
11148                         uint32_t _flags_save_string = ndr->flags;
11149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11150                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11151                         if (_ptr_driver_name) {
11152                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11153                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11154                         } else {
11155                                 r->driver_name = NULL;
11156                         }
11157                         ndr->flags = _flags_save_string;
11158                 }
11159                 {
11160                         uint32_t _flags_save_string = ndr->flags;
11161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11162                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11163                         if (_ptr_architecture) {
11164                                 NDR_PULL_ALLOC(ndr, r->architecture);
11165                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11166                         } else {
11167                                 r->architecture = NULL;
11168                         }
11169                         ndr->flags = _flags_save_string;
11170                 }
11171                 {
11172                         uint32_t _flags_save_string = ndr->flags;
11173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11175                         if (_ptr_driver_path) {
11176                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11178                         } else {
11179                                 r->driver_path = NULL;
11180                         }
11181                         ndr->flags = _flags_save_string;
11182                 }
11183                 {
11184                         uint32_t _flags_save_string = ndr->flags;
11185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11186                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11187                         if (_ptr_data_file) {
11188                                 NDR_PULL_ALLOC(ndr, r->data_file);
11189                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11190                         } else {
11191                                 r->data_file = NULL;
11192                         }
11193                         ndr->flags = _flags_save_string;
11194                 }
11195                 {
11196                         uint32_t _flags_save_string = ndr->flags;
11197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11198                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11199                         if (_ptr_config_file) {
11200                                 NDR_PULL_ALLOC(ndr, r->config_file);
11201                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11202                         } else {
11203                                 r->config_file = NULL;
11204                         }
11205                         ndr->flags = _flags_save_string;
11206                 }
11207                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11208         }
11209         if (ndr_flags & NDR_BUFFERS) {
11210                 {
11211                         uint32_t _flags_save_string = ndr->flags;
11212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11213                         if (r->driver_name) {
11214                                 uint32_t _relative_save_offset;
11215                                 _relative_save_offset = ndr->offset;
11216                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11217                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11218                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11219                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11220                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11221                                 if (ndr->offset > ndr->relative_highest_offset) {
11222                                         ndr->relative_highest_offset = ndr->offset;
11223                                 }
11224                                 ndr->offset = _relative_save_offset;
11225                         }
11226                         ndr->flags = _flags_save_string;
11227                 }
11228                 {
11229                         uint32_t _flags_save_string = ndr->flags;
11230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11231                         if (r->architecture) {
11232                                 uint32_t _relative_save_offset;
11233                                 _relative_save_offset = ndr->offset;
11234                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11235                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11236                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11237                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11238                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11239                                 if (ndr->offset > ndr->relative_highest_offset) {
11240                                         ndr->relative_highest_offset = ndr->offset;
11241                                 }
11242                                 ndr->offset = _relative_save_offset;
11243                         }
11244                         ndr->flags = _flags_save_string;
11245                 }
11246                 {
11247                         uint32_t _flags_save_string = ndr->flags;
11248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11249                         if (r->driver_path) {
11250                                 uint32_t _relative_save_offset;
11251                                 _relative_save_offset = ndr->offset;
11252                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11253                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11254                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11255                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11256                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11257                                 if (ndr->offset > ndr->relative_highest_offset) {
11258                                         ndr->relative_highest_offset = ndr->offset;
11259                                 }
11260                                 ndr->offset = _relative_save_offset;
11261                         }
11262                         ndr->flags = _flags_save_string;
11263                 }
11264                 {
11265                         uint32_t _flags_save_string = ndr->flags;
11266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11267                         if (r->data_file) {
11268                                 uint32_t _relative_save_offset;
11269                                 _relative_save_offset = ndr->offset;
11270                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11271                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11272                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11273                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11274                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11275                                 if (ndr->offset > ndr->relative_highest_offset) {
11276                                         ndr->relative_highest_offset = ndr->offset;
11277                                 }
11278                                 ndr->offset = _relative_save_offset;
11279                         }
11280                         ndr->flags = _flags_save_string;
11281                 }
11282                 {
11283                         uint32_t _flags_save_string = ndr->flags;
11284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11285                         if (r->config_file) {
11286                                 uint32_t _relative_save_offset;
11287                                 _relative_save_offset = ndr->offset;
11288                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11289                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11290                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11291                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11292                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11293                                 if (ndr->offset > ndr->relative_highest_offset) {
11294                                         ndr->relative_highest_offset = ndr->offset;
11295                                 }
11296                                 ndr->offset = _relative_save_offset;
11297                         }
11298                         ndr->flags = _flags_save_string;
11299                 }
11300         }
11301         return NDR_ERR_SUCCESS;
11302 }
11303
11304 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
11305 {
11306         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
11307         ndr->depth++;
11308         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11309         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11310         ndr->depth++;
11311         if (r->driver_name) {
11312                 ndr_print_string(ndr, "driver_name", r->driver_name);
11313         }
11314         ndr->depth--;
11315         ndr_print_ptr(ndr, "architecture", r->architecture);
11316         ndr->depth++;
11317         if (r->architecture) {
11318                 ndr_print_string(ndr, "architecture", r->architecture);
11319         }
11320         ndr->depth--;
11321         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11322         ndr->depth++;
11323         if (r->driver_path) {
11324                 ndr_print_string(ndr, "driver_path", r->driver_path);
11325         }
11326         ndr->depth--;
11327         ndr_print_ptr(ndr, "data_file", r->data_file);
11328         ndr->depth++;
11329         if (r->data_file) {
11330                 ndr_print_string(ndr, "data_file", r->data_file);
11331         }
11332         ndr->depth--;
11333         ndr_print_ptr(ndr, "config_file", r->config_file);
11334         ndr->depth++;
11335         if (r->config_file) {
11336                 ndr_print_string(ndr, "config_file", r->config_file);
11337         }
11338         ndr->depth--;
11339         ndr->depth--;
11340 }
11341
11342 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
11343 {
11344         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
11345 }
11346
11347 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
11348 {
11349         if (ndr_flags & NDR_SCALARS) {
11350                 NDR_CHECK(ndr_push_align(ndr, 5));
11351                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11352                 {
11353                         uint32_t _flags_save_string = ndr->flags;
11354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11355                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11356                         ndr->flags = _flags_save_string;
11357                 }
11358                 {
11359                         uint32_t _flags_save_string = ndr->flags;
11360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11361                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11362                         ndr->flags = _flags_save_string;
11363                 }
11364                 {
11365                         uint32_t _flags_save_string = ndr->flags;
11366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11368                         ndr->flags = _flags_save_string;
11369                 }
11370                 {
11371                         uint32_t _flags_save_string = ndr->flags;
11372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11374                         ndr->flags = _flags_save_string;
11375                 }
11376                 {
11377                         uint32_t _flags_save_string = ndr->flags;
11378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11379                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11380                         ndr->flags = _flags_save_string;
11381                 }
11382                 {
11383                         uint32_t _flags_save_string = ndr->flags;
11384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11385                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11386                         ndr->flags = _flags_save_string;
11387                 }
11388                 {
11389                         uint32_t _flags_save_string_array = ndr->flags;
11390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11391                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11392                         ndr->flags = _flags_save_string_array;
11393                 }
11394                 {
11395                         uint32_t _flags_save_string = ndr->flags;
11396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11397                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11398                         ndr->flags = _flags_save_string;
11399                 }
11400                 {
11401                         uint32_t _flags_save_string = ndr->flags;
11402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11403                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11404                         ndr->flags = _flags_save_string;
11405                 }
11406                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11407         }
11408         if (ndr_flags & NDR_BUFFERS) {
11409                 {
11410                         uint32_t _flags_save_string = ndr->flags;
11411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11412                         if (r->driver_name) {
11413                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11414                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11415                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11416                         }
11417                         ndr->flags = _flags_save_string;
11418                 }
11419                 {
11420                         uint32_t _flags_save_string = ndr->flags;
11421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11422                         if (r->architecture) {
11423                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11424                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11425                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11426                         }
11427                         ndr->flags = _flags_save_string;
11428                 }
11429                 {
11430                         uint32_t _flags_save_string = ndr->flags;
11431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11432                         if (r->driver_path) {
11433                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11434                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11435                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11436                         }
11437                         ndr->flags = _flags_save_string;
11438                 }
11439                 {
11440                         uint32_t _flags_save_string = ndr->flags;
11441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11442                         if (r->data_file) {
11443                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11444                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11445                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11446                         }
11447                         ndr->flags = _flags_save_string;
11448                 }
11449                 {
11450                         uint32_t _flags_save_string = ndr->flags;
11451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11452                         if (r->config_file) {
11453                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11454                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11455                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11456                         }
11457                         ndr->flags = _flags_save_string;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         if (r->help_file) {
11463                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11464                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11465                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11466                         }
11467                         ndr->flags = _flags_save_string;
11468                 }
11469                 {
11470                         uint32_t _flags_save_string_array = ndr->flags;
11471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11472                         if (r->dependent_files) {
11473                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
11474                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11475                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
11476                         }
11477                         ndr->flags = _flags_save_string_array;
11478                 }
11479                 {
11480                         uint32_t _flags_save_string = ndr->flags;
11481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11482                         if (r->monitor_name) {
11483                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
11484                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11485                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
11486                         }
11487                         ndr->flags = _flags_save_string;
11488                 }
11489                 {
11490                         uint32_t _flags_save_string = ndr->flags;
11491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11492                         if (r->default_datatype) {
11493                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
11494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11495                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
11496                         }
11497                         ndr->flags = _flags_save_string;
11498                 }
11499         }
11500         return NDR_ERR_SUCCESS;
11501 }
11502
11503 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11504 {
11505         uint32_t _ptr_driver_name;
11506         TALLOC_CTX *_mem_save_driver_name_0;
11507         uint32_t _ptr_architecture;
11508         TALLOC_CTX *_mem_save_architecture_0;
11509         uint32_t _ptr_driver_path;
11510         TALLOC_CTX *_mem_save_driver_path_0;
11511         uint32_t _ptr_data_file;
11512         TALLOC_CTX *_mem_save_data_file_0;
11513         uint32_t _ptr_config_file;
11514         TALLOC_CTX *_mem_save_config_file_0;
11515         uint32_t _ptr_help_file;
11516         TALLOC_CTX *_mem_save_help_file_0;
11517         uint32_t _ptr_dependent_files;
11518         TALLOC_CTX *_mem_save_dependent_files_0;
11519         uint32_t _ptr_monitor_name;
11520         TALLOC_CTX *_mem_save_monitor_name_0;
11521         uint32_t _ptr_default_datatype;
11522         TALLOC_CTX *_mem_save_default_datatype_0;
11523         if (ndr_flags & NDR_SCALARS) {
11524                 NDR_CHECK(ndr_pull_align(ndr, 5));
11525                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11526                 {
11527                         uint32_t _flags_save_string = ndr->flags;
11528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11529                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11530                         if (_ptr_driver_name) {
11531                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11532                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11533                         } else {
11534                                 r->driver_name = NULL;
11535                         }
11536                         ndr->flags = _flags_save_string;
11537                 }
11538                 {
11539                         uint32_t _flags_save_string = ndr->flags;
11540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11541                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11542                         if (_ptr_architecture) {
11543                                 NDR_PULL_ALLOC(ndr, r->architecture);
11544                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11545                         } else {
11546                                 r->architecture = NULL;
11547                         }
11548                         ndr->flags = _flags_save_string;
11549                 }
11550                 {
11551                         uint32_t _flags_save_string = ndr->flags;
11552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11553                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11554                         if (_ptr_driver_path) {
11555                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11556                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11557                         } else {
11558                                 r->driver_path = NULL;
11559                         }
11560                         ndr->flags = _flags_save_string;
11561                 }
11562                 {
11563                         uint32_t _flags_save_string = ndr->flags;
11564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11566                         if (_ptr_data_file) {
11567                                 NDR_PULL_ALLOC(ndr, r->data_file);
11568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11569                         } else {
11570                                 r->data_file = NULL;
11571                         }
11572                         ndr->flags = _flags_save_string;
11573                 }
11574                 {
11575                         uint32_t _flags_save_string = ndr->flags;
11576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11577                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11578                         if (_ptr_config_file) {
11579                                 NDR_PULL_ALLOC(ndr, r->config_file);
11580                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11581                         } else {
11582                                 r->config_file = NULL;
11583                         }
11584                         ndr->flags = _flags_save_string;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11590                         if (_ptr_help_file) {
11591                                 NDR_PULL_ALLOC(ndr, r->help_file);
11592                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11593                         } else {
11594                                 r->help_file = NULL;
11595                         }
11596                         ndr->flags = _flags_save_string;
11597                 }
11598                 {
11599                         uint32_t _flags_save_string_array = ndr->flags;
11600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11601                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11602                         if (_ptr_dependent_files) {
11603                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11604                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11605                         } else {
11606                                 r->dependent_files = NULL;
11607                         }
11608                         ndr->flags = _flags_save_string_array;
11609                 }
11610                 {
11611                         uint32_t _flags_save_string = ndr->flags;
11612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11614                         if (_ptr_monitor_name) {
11615                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11617                         } else {
11618                                 r->monitor_name = NULL;
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11626                         if (_ptr_default_datatype) {
11627                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11628                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11629                         } else {
11630                                 r->default_datatype = NULL;
11631                         }
11632                         ndr->flags = _flags_save_string;
11633                 }
11634                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11635         }
11636         if (ndr_flags & NDR_BUFFERS) {
11637                 {
11638                         uint32_t _flags_save_string = ndr->flags;
11639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11640                         if (r->driver_name) {
11641                                 uint32_t _relative_save_offset;
11642                                 _relative_save_offset = ndr->offset;
11643                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11644                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11645                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11646                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11647                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11648                                 if (ndr->offset > ndr->relative_highest_offset) {
11649                                         ndr->relative_highest_offset = ndr->offset;
11650                                 }
11651                                 ndr->offset = _relative_save_offset;
11652                         }
11653                         ndr->flags = _flags_save_string;
11654                 }
11655                 {
11656                         uint32_t _flags_save_string = ndr->flags;
11657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11658                         if (r->architecture) {
11659                                 uint32_t _relative_save_offset;
11660                                 _relative_save_offset = ndr->offset;
11661                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11662                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11663                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11664                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11665                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11666                                 if (ndr->offset > ndr->relative_highest_offset) {
11667                                         ndr->relative_highest_offset = ndr->offset;
11668                                 }
11669                                 ndr->offset = _relative_save_offset;
11670                         }
11671                         ndr->flags = _flags_save_string;
11672                 }
11673                 {
11674                         uint32_t _flags_save_string = ndr->flags;
11675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11676                         if (r->driver_path) {
11677                                 uint32_t _relative_save_offset;
11678                                 _relative_save_offset = ndr->offset;
11679                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11680                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11681                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11682                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11683                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11684                                 if (ndr->offset > ndr->relative_highest_offset) {
11685                                         ndr->relative_highest_offset = ndr->offset;
11686                                 }
11687                                 ndr->offset = _relative_save_offset;
11688                         }
11689                         ndr->flags = _flags_save_string;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         if (r->data_file) {
11695                                 uint32_t _relative_save_offset;
11696                                 _relative_save_offset = ndr->offset;
11697                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11698                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11699                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11700                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11701                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11702                                 if (ndr->offset > ndr->relative_highest_offset) {
11703                                         ndr->relative_highest_offset = ndr->offset;
11704                                 }
11705                                 ndr->offset = _relative_save_offset;
11706                         }
11707                         ndr->flags = _flags_save_string;
11708                 }
11709                 {
11710                         uint32_t _flags_save_string = ndr->flags;
11711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11712                         if (r->config_file) {
11713                                 uint32_t _relative_save_offset;
11714                                 _relative_save_offset = ndr->offset;
11715                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11716                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11717                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11718                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11719                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11720                                 if (ndr->offset > ndr->relative_highest_offset) {
11721                                         ndr->relative_highest_offset = ndr->offset;
11722                                 }
11723                                 ndr->offset = _relative_save_offset;
11724                         }
11725                         ndr->flags = _flags_save_string;
11726                 }
11727                 {
11728                         uint32_t _flags_save_string = ndr->flags;
11729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11730                         if (r->help_file) {
11731                                 uint32_t _relative_save_offset;
11732                                 _relative_save_offset = ndr->offset;
11733                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11734                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11735                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11736                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11737                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11738                                 if (ndr->offset > ndr->relative_highest_offset) {
11739                                         ndr->relative_highest_offset = ndr->offset;
11740                                 }
11741                                 ndr->offset = _relative_save_offset;
11742                         }
11743                         ndr->flags = _flags_save_string;
11744                 }
11745                 {
11746                         uint32_t _flags_save_string_array = ndr->flags;
11747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11748                         if (r->dependent_files) {
11749                                 uint32_t _relative_save_offset;
11750                                 _relative_save_offset = ndr->offset;
11751                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11752                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11753                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11754                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11755                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11756                                 if (ndr->offset > ndr->relative_highest_offset) {
11757                                         ndr->relative_highest_offset = ndr->offset;
11758                                 }
11759                                 ndr->offset = _relative_save_offset;
11760                         }
11761                         ndr->flags = _flags_save_string_array;
11762                 }
11763                 {
11764                         uint32_t _flags_save_string = ndr->flags;
11765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11766                         if (r->monitor_name) {
11767                                 uint32_t _relative_save_offset;
11768                                 _relative_save_offset = ndr->offset;
11769                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11770                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11771                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11772                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11773                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11774                                 if (ndr->offset > ndr->relative_highest_offset) {
11775                                         ndr->relative_highest_offset = ndr->offset;
11776                                 }
11777                                 ndr->offset = _relative_save_offset;
11778                         }
11779                         ndr->flags = _flags_save_string;
11780                 }
11781                 {
11782                         uint32_t _flags_save_string = ndr->flags;
11783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11784                         if (r->default_datatype) {
11785                                 uint32_t _relative_save_offset;
11786                                 _relative_save_offset = ndr->offset;
11787                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11788                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11789                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11790                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11791                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11792                                 if (ndr->offset > ndr->relative_highest_offset) {
11793                                         ndr->relative_highest_offset = ndr->offset;
11794                                 }
11795                                 ndr->offset = _relative_save_offset;
11796                         }
11797                         ndr->flags = _flags_save_string;
11798                 }
11799         }
11800         return NDR_ERR_SUCCESS;
11801 }
11802
11803 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11804 {
11805         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11806         ndr->depth++;
11807         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11808         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11809         ndr->depth++;
11810         if (r->driver_name) {
11811                 ndr_print_string(ndr, "driver_name", r->driver_name);
11812         }
11813         ndr->depth--;
11814         ndr_print_ptr(ndr, "architecture", r->architecture);
11815         ndr->depth++;
11816         if (r->architecture) {
11817                 ndr_print_string(ndr, "architecture", r->architecture);
11818         }
11819         ndr->depth--;
11820         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11821         ndr->depth++;
11822         if (r->driver_path) {
11823                 ndr_print_string(ndr, "driver_path", r->driver_path);
11824         }
11825         ndr->depth--;
11826         ndr_print_ptr(ndr, "data_file", r->data_file);
11827         ndr->depth++;
11828         if (r->data_file) {
11829                 ndr_print_string(ndr, "data_file", r->data_file);
11830         }
11831         ndr->depth--;
11832         ndr_print_ptr(ndr, "config_file", r->config_file);
11833         ndr->depth++;
11834         if (r->config_file) {
11835                 ndr_print_string(ndr, "config_file", r->config_file);
11836         }
11837         ndr->depth--;
11838         ndr_print_ptr(ndr, "help_file", r->help_file);
11839         ndr->depth++;
11840         if (r->help_file) {
11841                 ndr_print_string(ndr, "help_file", r->help_file);
11842         }
11843         ndr->depth--;
11844         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11845         ndr->depth++;
11846         if (r->dependent_files) {
11847                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11848         }
11849         ndr->depth--;
11850         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11851         ndr->depth++;
11852         if (r->monitor_name) {
11853                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11854         }
11855         ndr->depth--;
11856         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11857         ndr->depth++;
11858         if (r->default_datatype) {
11859                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11860         }
11861         ndr->depth--;
11862         ndr->depth--;
11863 }
11864
11865 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11866 {
11867         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11868 }
11869
11870 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11871 {
11872         if (ndr_flags & NDR_SCALARS) {
11873                 NDR_CHECK(ndr_push_align(ndr, 5));
11874                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11875                 {
11876                         uint32_t _flags_save_string = ndr->flags;
11877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11878                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11885                         ndr->flags = _flags_save_string;
11886                 }
11887                 {
11888                         uint32_t _flags_save_string = ndr->flags;
11889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11890                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11891                         ndr->flags = _flags_save_string;
11892                 }
11893                 {
11894                         uint32_t _flags_save_string = ndr->flags;
11895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11896                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11897                         ndr->flags = _flags_save_string;
11898                 }
11899                 {
11900                         uint32_t _flags_save_string = ndr->flags;
11901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11903                         ndr->flags = _flags_save_string;
11904                 }
11905                 {
11906                         uint32_t _flags_save_string = ndr->flags;
11907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11909                         ndr->flags = _flags_save_string;
11910                 }
11911                 {
11912                         uint32_t _flags_save_string_array = ndr->flags;
11913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11914                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11915                         ndr->flags = _flags_save_string_array;
11916                 }
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11921                         ndr->flags = _flags_save_string;
11922                 }
11923                 {
11924                         uint32_t _flags_save_string = ndr->flags;
11925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11927                         ndr->flags = _flags_save_string;
11928                 }
11929                 {
11930                         uint32_t _flags_save_string_array = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11933                         ndr->flags = _flags_save_string_array;
11934                 }
11935                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11936         }
11937         if (ndr_flags & NDR_BUFFERS) {
11938                 {
11939                         uint32_t _flags_save_string = ndr->flags;
11940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11941                         if (r->driver_name) {
11942                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
11943                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11944                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
11945                         }
11946                         ndr->flags = _flags_save_string;
11947                 }
11948                 {
11949                         uint32_t _flags_save_string = ndr->flags;
11950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11951                         if (r->architecture) {
11952                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
11953                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11954                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
11955                         }
11956                         ndr->flags = _flags_save_string;
11957                 }
11958                 {
11959                         uint32_t _flags_save_string = ndr->flags;
11960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11961                         if (r->driver_path) {
11962                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
11963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11964                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
11965                         }
11966                         ndr->flags = _flags_save_string;
11967                 }
11968                 {
11969                         uint32_t _flags_save_string = ndr->flags;
11970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11971                         if (r->data_file) {
11972                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
11973                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11974                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
11975                         }
11976                         ndr->flags = _flags_save_string;
11977                 }
11978                 {
11979                         uint32_t _flags_save_string = ndr->flags;
11980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11981                         if (r->config_file) {
11982                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
11983                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11984                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
11985                         }
11986                         ndr->flags = _flags_save_string;
11987                 }
11988                 {
11989                         uint32_t _flags_save_string = ndr->flags;
11990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11991                         if (r->help_file) {
11992                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
11993                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11994                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
11995                         }
11996                         ndr->flags = _flags_save_string;
11997                 }
11998                 {
11999                         uint32_t _flags_save_string_array = ndr->flags;
12000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12001                         if (r->dependent_files) {
12002                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12003                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12004                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12005                         }
12006                         ndr->flags = _flags_save_string_array;
12007                 }
12008                 {
12009                         uint32_t _flags_save_string = ndr->flags;
12010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12011                         if (r->monitor_name) {
12012                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12013                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12014                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12015                         }
12016                         ndr->flags = _flags_save_string;
12017                 }
12018                 {
12019                         uint32_t _flags_save_string = ndr->flags;
12020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12021                         if (r->default_datatype) {
12022                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12023                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12024                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12025                         }
12026                         ndr->flags = _flags_save_string;
12027                 }
12028                 {
12029                         uint32_t _flags_save_string_array = ndr->flags;
12030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12031                         if (r->previous_names) {
12032                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12033                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12034                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12035                         }
12036                         ndr->flags = _flags_save_string_array;
12037                 }
12038         }
12039         return NDR_ERR_SUCCESS;
12040 }
12041
12042 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
12043 {
12044         uint32_t _ptr_driver_name;
12045         TALLOC_CTX *_mem_save_driver_name_0;
12046         uint32_t _ptr_architecture;
12047         TALLOC_CTX *_mem_save_architecture_0;
12048         uint32_t _ptr_driver_path;
12049         TALLOC_CTX *_mem_save_driver_path_0;
12050         uint32_t _ptr_data_file;
12051         TALLOC_CTX *_mem_save_data_file_0;
12052         uint32_t _ptr_config_file;
12053         TALLOC_CTX *_mem_save_config_file_0;
12054         uint32_t _ptr_help_file;
12055         TALLOC_CTX *_mem_save_help_file_0;
12056         uint32_t _ptr_dependent_files;
12057         TALLOC_CTX *_mem_save_dependent_files_0;
12058         uint32_t _ptr_monitor_name;
12059         TALLOC_CTX *_mem_save_monitor_name_0;
12060         uint32_t _ptr_default_datatype;
12061         TALLOC_CTX *_mem_save_default_datatype_0;
12062         uint32_t _ptr_previous_names;
12063         TALLOC_CTX *_mem_save_previous_names_0;
12064         if (ndr_flags & NDR_SCALARS) {
12065                 NDR_CHECK(ndr_pull_align(ndr, 5));
12066                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12067                 {
12068                         uint32_t _flags_save_string = ndr->flags;
12069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12071                         if (_ptr_driver_name) {
12072                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12074                         } else {
12075                                 r->driver_name = NULL;
12076                         }
12077                         ndr->flags = _flags_save_string;
12078                 }
12079                 {
12080                         uint32_t _flags_save_string = ndr->flags;
12081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12083                         if (_ptr_architecture) {
12084                                 NDR_PULL_ALLOC(ndr, r->architecture);
12085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12086                         } else {
12087                                 r->architecture = NULL;
12088                         }
12089                         ndr->flags = _flags_save_string;
12090                 }
12091                 {
12092                         uint32_t _flags_save_string = ndr->flags;
12093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12094                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12095                         if (_ptr_driver_path) {
12096                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12097                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12098                         } else {
12099                                 r->driver_path = NULL;
12100                         }
12101                         ndr->flags = _flags_save_string;
12102                 }
12103                 {
12104                         uint32_t _flags_save_string = ndr->flags;
12105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12107                         if (_ptr_data_file) {
12108                                 NDR_PULL_ALLOC(ndr, r->data_file);
12109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12110                         } else {
12111                                 r->data_file = NULL;
12112                         }
12113                         ndr->flags = _flags_save_string;
12114                 }
12115                 {
12116                         uint32_t _flags_save_string = ndr->flags;
12117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12119                         if (_ptr_config_file) {
12120                                 NDR_PULL_ALLOC(ndr, r->config_file);
12121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12122                         } else {
12123                                 r->config_file = NULL;
12124                         }
12125                         ndr->flags = _flags_save_string;
12126                 }
12127                 {
12128                         uint32_t _flags_save_string = ndr->flags;
12129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12131                         if (_ptr_help_file) {
12132                                 NDR_PULL_ALLOC(ndr, r->help_file);
12133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12134                         } else {
12135                                 r->help_file = NULL;
12136                         }
12137                         ndr->flags = _flags_save_string;
12138                 }
12139                 {
12140                         uint32_t _flags_save_string_array = ndr->flags;
12141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12143                         if (_ptr_dependent_files) {
12144                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12146                         } else {
12147                                 r->dependent_files = NULL;
12148                         }
12149                         ndr->flags = _flags_save_string_array;
12150                 }
12151                 {
12152                         uint32_t _flags_save_string = ndr->flags;
12153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12155                         if (_ptr_monitor_name) {
12156                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12158                         } else {
12159                                 r->monitor_name = NULL;
12160                         }
12161                         ndr->flags = _flags_save_string;
12162                 }
12163                 {
12164                         uint32_t _flags_save_string = ndr->flags;
12165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12167                         if (_ptr_default_datatype) {
12168                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12170                         } else {
12171                                 r->default_datatype = NULL;
12172                         }
12173                         ndr->flags = _flags_save_string;
12174                 }
12175                 {
12176                         uint32_t _flags_save_string_array = ndr->flags;
12177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12179                         if (_ptr_previous_names) {
12180                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12182                         } else {
12183                                 r->previous_names = NULL;
12184                         }
12185                         ndr->flags = _flags_save_string_array;
12186                 }
12187                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12188         }
12189         if (ndr_flags & NDR_BUFFERS) {
12190                 {
12191                         uint32_t _flags_save_string = ndr->flags;
12192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12193                         if (r->driver_name) {
12194                                 uint32_t _relative_save_offset;
12195                                 _relative_save_offset = ndr->offset;
12196                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12197                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12198                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12199                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12200                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12201                                 if (ndr->offset > ndr->relative_highest_offset) {
12202                                         ndr->relative_highest_offset = ndr->offset;
12203                                 }
12204                                 ndr->offset = _relative_save_offset;
12205                         }
12206                         ndr->flags = _flags_save_string;
12207                 }
12208                 {
12209                         uint32_t _flags_save_string = ndr->flags;
12210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12211                         if (r->architecture) {
12212                                 uint32_t _relative_save_offset;
12213                                 _relative_save_offset = ndr->offset;
12214                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12215                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12216                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12217                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12218                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12219                                 if (ndr->offset > ndr->relative_highest_offset) {
12220                                         ndr->relative_highest_offset = ndr->offset;
12221                                 }
12222                                 ndr->offset = _relative_save_offset;
12223                         }
12224                         ndr->flags = _flags_save_string;
12225                 }
12226                 {
12227                         uint32_t _flags_save_string = ndr->flags;
12228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12229                         if (r->driver_path) {
12230                                 uint32_t _relative_save_offset;
12231                                 _relative_save_offset = ndr->offset;
12232                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12233                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12234                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12235                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12236                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12237                                 if (ndr->offset > ndr->relative_highest_offset) {
12238                                         ndr->relative_highest_offset = ndr->offset;
12239                                 }
12240                                 ndr->offset = _relative_save_offset;
12241                         }
12242                         ndr->flags = _flags_save_string;
12243                 }
12244                 {
12245                         uint32_t _flags_save_string = ndr->flags;
12246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12247                         if (r->data_file) {
12248                                 uint32_t _relative_save_offset;
12249                                 _relative_save_offset = ndr->offset;
12250                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12251                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12252                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12253                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12254                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12255                                 if (ndr->offset > ndr->relative_highest_offset) {
12256                                         ndr->relative_highest_offset = ndr->offset;
12257                                 }
12258                                 ndr->offset = _relative_save_offset;
12259                         }
12260                         ndr->flags = _flags_save_string;
12261                 }
12262                 {
12263                         uint32_t _flags_save_string = ndr->flags;
12264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12265                         if (r->config_file) {
12266                                 uint32_t _relative_save_offset;
12267                                 _relative_save_offset = ndr->offset;
12268                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12269                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12270                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12271                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12272                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12273                                 if (ndr->offset > ndr->relative_highest_offset) {
12274                                         ndr->relative_highest_offset = ndr->offset;
12275                                 }
12276                                 ndr->offset = _relative_save_offset;
12277                         }
12278                         ndr->flags = _flags_save_string;
12279                 }
12280                 {
12281                         uint32_t _flags_save_string = ndr->flags;
12282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12283                         if (r->help_file) {
12284                                 uint32_t _relative_save_offset;
12285                                 _relative_save_offset = ndr->offset;
12286                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12287                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12288                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12289                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12290                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12291                                 if (ndr->offset > ndr->relative_highest_offset) {
12292                                         ndr->relative_highest_offset = ndr->offset;
12293                                 }
12294                                 ndr->offset = _relative_save_offset;
12295                         }
12296                         ndr->flags = _flags_save_string;
12297                 }
12298                 {
12299                         uint32_t _flags_save_string_array = ndr->flags;
12300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12301                         if (r->dependent_files) {
12302                                 uint32_t _relative_save_offset;
12303                                 _relative_save_offset = ndr->offset;
12304                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12305                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12306                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12307                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12308                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12309                                 if (ndr->offset > ndr->relative_highest_offset) {
12310                                         ndr->relative_highest_offset = ndr->offset;
12311                                 }
12312                                 ndr->offset = _relative_save_offset;
12313                         }
12314                         ndr->flags = _flags_save_string_array;
12315                 }
12316                 {
12317                         uint32_t _flags_save_string = ndr->flags;
12318                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12319                         if (r->monitor_name) {
12320                                 uint32_t _relative_save_offset;
12321                                 _relative_save_offset = ndr->offset;
12322                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12323                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12324                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12325                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12326                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12327                                 if (ndr->offset > ndr->relative_highest_offset) {
12328                                         ndr->relative_highest_offset = ndr->offset;
12329                                 }
12330                                 ndr->offset = _relative_save_offset;
12331                         }
12332                         ndr->flags = _flags_save_string;
12333                 }
12334                 {
12335                         uint32_t _flags_save_string = ndr->flags;
12336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12337                         if (r->default_datatype) {
12338                                 uint32_t _relative_save_offset;
12339                                 _relative_save_offset = ndr->offset;
12340                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12341                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12342                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12343                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12344                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12345                                 if (ndr->offset > ndr->relative_highest_offset) {
12346                                         ndr->relative_highest_offset = ndr->offset;
12347                                 }
12348                                 ndr->offset = _relative_save_offset;
12349                         }
12350                         ndr->flags = _flags_save_string;
12351                 }
12352                 {
12353                         uint32_t _flags_save_string_array = ndr->flags;
12354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12355                         if (r->previous_names) {
12356                                 uint32_t _relative_save_offset;
12357                                 _relative_save_offset = ndr->offset;
12358                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12359                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12360                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12361                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12362                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12363                                 if (ndr->offset > ndr->relative_highest_offset) {
12364                                         ndr->relative_highest_offset = ndr->offset;
12365                                 }
12366                                 ndr->offset = _relative_save_offset;
12367                         }
12368                         ndr->flags = _flags_save_string_array;
12369                 }
12370         }
12371         return NDR_ERR_SUCCESS;
12372 }
12373
12374 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
12375 {
12376         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
12377         ndr->depth++;
12378         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12379         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12380         ndr->depth++;
12381         if (r->driver_name) {
12382                 ndr_print_string(ndr, "driver_name", r->driver_name);
12383         }
12384         ndr->depth--;
12385         ndr_print_ptr(ndr, "architecture", r->architecture);
12386         ndr->depth++;
12387         if (r->architecture) {
12388                 ndr_print_string(ndr, "architecture", r->architecture);
12389         }
12390         ndr->depth--;
12391         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12392         ndr->depth++;
12393         if (r->driver_path) {
12394                 ndr_print_string(ndr, "driver_path", r->driver_path);
12395         }
12396         ndr->depth--;
12397         ndr_print_ptr(ndr, "data_file", r->data_file);
12398         ndr->depth++;
12399         if (r->data_file) {
12400                 ndr_print_string(ndr, "data_file", r->data_file);
12401         }
12402         ndr->depth--;
12403         ndr_print_ptr(ndr, "config_file", r->config_file);
12404         ndr->depth++;
12405         if (r->config_file) {
12406                 ndr_print_string(ndr, "config_file", r->config_file);
12407         }
12408         ndr->depth--;
12409         ndr_print_ptr(ndr, "help_file", r->help_file);
12410         ndr->depth++;
12411         if (r->help_file) {
12412                 ndr_print_string(ndr, "help_file", r->help_file);
12413         }
12414         ndr->depth--;
12415         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12416         ndr->depth++;
12417         if (r->dependent_files) {
12418                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12419         }
12420         ndr->depth--;
12421         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12422         ndr->depth++;
12423         if (r->monitor_name) {
12424                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12425         }
12426         ndr->depth--;
12427         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12428         ndr->depth++;
12429         if (r->default_datatype) {
12430                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12431         }
12432         ndr->depth--;
12433         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12434         ndr->depth++;
12435         if (r->previous_names) {
12436                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12437         }
12438         ndr->depth--;
12439         ndr->depth--;
12440 }
12441
12442 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12443 {
12444         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12445 }
12446
12447 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12448 {
12449         if (ndr_flags & NDR_SCALARS) {
12450                 NDR_CHECK(ndr_push_align(ndr, 5));
12451                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12452                 {
12453                         uint32_t _flags_save_string = ndr->flags;
12454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12456                         ndr->flags = _flags_save_string;
12457                 }
12458                 {
12459                         uint32_t _flags_save_string = ndr->flags;
12460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12461                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12462                         ndr->flags = _flags_save_string;
12463                 }
12464                 {
12465                         uint32_t _flags_save_string = ndr->flags;
12466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12468                         ndr->flags = _flags_save_string;
12469                 }
12470                 {
12471                         uint32_t _flags_save_string = ndr->flags;
12472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12474                         ndr->flags = _flags_save_string;
12475                 }
12476                 {
12477                         uint32_t _flags_save_string = ndr->flags;
12478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12480                         ndr->flags = _flags_save_string;
12481                 }
12482                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12485                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12486         }
12487         if (ndr_flags & NDR_BUFFERS) {
12488                 {
12489                         uint32_t _flags_save_string = ndr->flags;
12490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12491                         if (r->driver_name) {
12492                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12493                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12494                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
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->architecture) {
12502                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12503                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12504                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12505                         }
12506                         ndr->flags = _flags_save_string;
12507                 }
12508                 {
12509                         uint32_t _flags_save_string = ndr->flags;
12510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12511                         if (r->driver_path) {
12512                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12513                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12514                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12515                         }
12516                         ndr->flags = _flags_save_string;
12517                 }
12518                 {
12519                         uint32_t _flags_save_string = ndr->flags;
12520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12521                         if (r->data_file) {
12522                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12523                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12524                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12525                         }
12526                         ndr->flags = _flags_save_string;
12527                 }
12528                 {
12529                         uint32_t _flags_save_string = ndr->flags;
12530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12531                         if (r->config_file) {
12532                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12533                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12534                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12535                         }
12536                         ndr->flags = _flags_save_string;
12537                 }
12538         }
12539         return NDR_ERR_SUCCESS;
12540 }
12541
12542 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12543 {
12544         uint32_t _ptr_driver_name;
12545         TALLOC_CTX *_mem_save_driver_name_0;
12546         uint32_t _ptr_architecture;
12547         TALLOC_CTX *_mem_save_architecture_0;
12548         uint32_t _ptr_driver_path;
12549         TALLOC_CTX *_mem_save_driver_path_0;
12550         uint32_t _ptr_data_file;
12551         TALLOC_CTX *_mem_save_data_file_0;
12552         uint32_t _ptr_config_file;
12553         TALLOC_CTX *_mem_save_config_file_0;
12554         if (ndr_flags & NDR_SCALARS) {
12555                 NDR_CHECK(ndr_pull_align(ndr, 5));
12556                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12557                 {
12558                         uint32_t _flags_save_string = ndr->flags;
12559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12561                         if (_ptr_driver_name) {
12562                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12564                         } else {
12565                                 r->driver_name = NULL;
12566                         }
12567                         ndr->flags = _flags_save_string;
12568                 }
12569                 {
12570                         uint32_t _flags_save_string = ndr->flags;
12571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12572                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12573                         if (_ptr_architecture) {
12574                                 NDR_PULL_ALLOC(ndr, r->architecture);
12575                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12576                         } else {
12577                                 r->architecture = NULL;
12578                         }
12579                         ndr->flags = _flags_save_string;
12580                 }
12581                 {
12582                         uint32_t _flags_save_string = ndr->flags;
12583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12584                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12585                         if (_ptr_driver_path) {
12586                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12587                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12588                         } else {
12589                                 r->driver_path = NULL;
12590                         }
12591                         ndr->flags = _flags_save_string;
12592                 }
12593                 {
12594                         uint32_t _flags_save_string = ndr->flags;
12595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12596                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12597                         if (_ptr_data_file) {
12598                                 NDR_PULL_ALLOC(ndr, r->data_file);
12599                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12600                         } else {
12601                                 r->data_file = NULL;
12602                         }
12603                         ndr->flags = _flags_save_string;
12604                 }
12605                 {
12606                         uint32_t _flags_save_string = ndr->flags;
12607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12608                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12609                         if (_ptr_config_file) {
12610                                 NDR_PULL_ALLOC(ndr, r->config_file);
12611                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12612                         } else {
12613                                 r->config_file = NULL;
12614                         }
12615                         ndr->flags = _flags_save_string;
12616                 }
12617                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12620                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12621         }
12622         if (ndr_flags & NDR_BUFFERS) {
12623                 {
12624                         uint32_t _flags_save_string = ndr->flags;
12625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12626                         if (r->driver_name) {
12627                                 uint32_t _relative_save_offset;
12628                                 _relative_save_offset = ndr->offset;
12629                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12630                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12631                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12632                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12633                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12634                                 if (ndr->offset > ndr->relative_highest_offset) {
12635                                         ndr->relative_highest_offset = ndr->offset;
12636                                 }
12637                                 ndr->offset = _relative_save_offset;
12638                         }
12639                         ndr->flags = _flags_save_string;
12640                 }
12641                 {
12642                         uint32_t _flags_save_string = ndr->flags;
12643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12644                         if (r->architecture) {
12645                                 uint32_t _relative_save_offset;
12646                                 _relative_save_offset = ndr->offset;
12647                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12648                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12649                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12650                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12651                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12652                                 if (ndr->offset > ndr->relative_highest_offset) {
12653                                         ndr->relative_highest_offset = ndr->offset;
12654                                 }
12655                                 ndr->offset = _relative_save_offset;
12656                         }
12657                         ndr->flags = _flags_save_string;
12658                 }
12659                 {
12660                         uint32_t _flags_save_string = ndr->flags;
12661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12662                         if (r->driver_path) {
12663                                 uint32_t _relative_save_offset;
12664                                 _relative_save_offset = ndr->offset;
12665                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12666                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12667                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12668                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12669                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12670                                 if (ndr->offset > ndr->relative_highest_offset) {
12671                                         ndr->relative_highest_offset = ndr->offset;
12672                                 }
12673                                 ndr->offset = _relative_save_offset;
12674                         }
12675                         ndr->flags = _flags_save_string;
12676                 }
12677                 {
12678                         uint32_t _flags_save_string = ndr->flags;
12679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12680                         if (r->data_file) {
12681                                 uint32_t _relative_save_offset;
12682                                 _relative_save_offset = ndr->offset;
12683                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12684                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12685                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12686                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12687                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12688                                 if (ndr->offset > ndr->relative_highest_offset) {
12689                                         ndr->relative_highest_offset = ndr->offset;
12690                                 }
12691                                 ndr->offset = _relative_save_offset;
12692                         }
12693                         ndr->flags = _flags_save_string;
12694                 }
12695                 {
12696                         uint32_t _flags_save_string = ndr->flags;
12697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12698                         if (r->config_file) {
12699                                 uint32_t _relative_save_offset;
12700                                 _relative_save_offset = ndr->offset;
12701                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12702                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12703                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12704                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12705                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12706                                 if (ndr->offset > ndr->relative_highest_offset) {
12707                                         ndr->relative_highest_offset = ndr->offset;
12708                                 }
12709                                 ndr->offset = _relative_save_offset;
12710                         }
12711                         ndr->flags = _flags_save_string;
12712                 }
12713         }
12714         return NDR_ERR_SUCCESS;
12715 }
12716
12717 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12718 {
12719         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12720         ndr->depth++;
12721         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12722         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12723         ndr->depth++;
12724         if (r->driver_name) {
12725                 ndr_print_string(ndr, "driver_name", r->driver_name);
12726         }
12727         ndr->depth--;
12728         ndr_print_ptr(ndr, "architecture", r->architecture);
12729         ndr->depth++;
12730         if (r->architecture) {
12731                 ndr_print_string(ndr, "architecture", r->architecture);
12732         }
12733         ndr->depth--;
12734         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12735         ndr->depth++;
12736         if (r->driver_path) {
12737                 ndr_print_string(ndr, "driver_path", r->driver_path);
12738         }
12739         ndr->depth--;
12740         ndr_print_ptr(ndr, "data_file", r->data_file);
12741         ndr->depth++;
12742         if (r->data_file) {
12743                 ndr_print_string(ndr, "data_file", r->data_file);
12744         }
12745         ndr->depth--;
12746         ndr_print_ptr(ndr, "config_file", r->config_file);
12747         ndr->depth++;
12748         if (r->config_file) {
12749                 ndr_print_string(ndr, "config_file", r->config_file);
12750         }
12751         ndr->depth--;
12752         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12753         ndr_print_uint32(ndr, "config_version", r->config_version);
12754         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12755         ndr->depth--;
12756 }
12757
12758 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12759 {
12760         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12761 }
12762
12763 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12764 {
12765         if (ndr_flags & NDR_SCALARS) {
12766                 NDR_CHECK(ndr_push_align(ndr, 8));
12767                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12768                 {
12769                         uint32_t _flags_save_string = ndr->flags;
12770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12771                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12772                         ndr->flags = _flags_save_string;
12773                 }
12774                 {
12775                         uint32_t _flags_save_string = ndr->flags;
12776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12777                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12778                         ndr->flags = _flags_save_string;
12779                 }
12780                 {
12781                         uint32_t _flags_save_string = ndr->flags;
12782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12783                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12784                         ndr->flags = _flags_save_string;
12785                 }
12786                 {
12787                         uint32_t _flags_save_string = ndr->flags;
12788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12789                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12790                         ndr->flags = _flags_save_string;
12791                 }
12792                 {
12793                         uint32_t _flags_save_string = ndr->flags;
12794                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12795                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12796                         ndr->flags = _flags_save_string;
12797                 }
12798                 {
12799                         uint32_t _flags_save_string = ndr->flags;
12800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12801                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12802                         ndr->flags = _flags_save_string;
12803                 }
12804                 {
12805                         uint32_t _flags_save_string_array = ndr->flags;
12806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12807                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12808                         ndr->flags = _flags_save_string_array;
12809                 }
12810                 {
12811                         uint32_t _flags_save_string = ndr->flags;
12812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12813                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12820                         ndr->flags = _flags_save_string;
12821                 }
12822                 {
12823                         uint32_t _flags_save_string_array = ndr->flags;
12824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12825                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12826                         ndr->flags = _flags_save_string_array;
12827                 }
12828                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12829                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12830                 {
12831                         uint32_t _flags_save_string = ndr->flags;
12832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12833                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12834                         ndr->flags = _flags_save_string;
12835                 }
12836                 {
12837                         uint32_t _flags_save_string = ndr->flags;
12838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12839                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12840                         ndr->flags = _flags_save_string;
12841                 }
12842                 {
12843                         uint32_t _flags_save_string = ndr->flags;
12844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12845                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12846                         ndr->flags = _flags_save_string;
12847                 }
12848                 {
12849                         uint32_t _flags_save_string = ndr->flags;
12850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12851                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12852                         ndr->flags = _flags_save_string;
12853                 }
12854                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12855         }
12856         if (ndr_flags & NDR_BUFFERS) {
12857                 {
12858                         uint32_t _flags_save_string = ndr->flags;
12859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12860                         if (r->driver_name) {
12861                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
12862                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12863                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
12864                         }
12865                         ndr->flags = _flags_save_string;
12866                 }
12867                 {
12868                         uint32_t _flags_save_string = ndr->flags;
12869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12870                         if (r->architecture) {
12871                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
12872                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12873                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
12874                         }
12875                         ndr->flags = _flags_save_string;
12876                 }
12877                 {
12878                         uint32_t _flags_save_string = ndr->flags;
12879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12880                         if (r->driver_path) {
12881                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
12882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12883                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
12884                         }
12885                         ndr->flags = _flags_save_string;
12886                 }
12887                 {
12888                         uint32_t _flags_save_string = ndr->flags;
12889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12890                         if (r->data_file) {
12891                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
12892                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12893                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->config_file) {
12901                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
12902                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12903                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
12904                         }
12905                         ndr->flags = _flags_save_string;
12906                 }
12907                 {
12908                         uint32_t _flags_save_string = ndr->flags;
12909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12910                         if (r->help_file) {
12911                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
12912                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12913                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
12914                         }
12915                         ndr->flags = _flags_save_string;
12916                 }
12917                 {
12918                         uint32_t _flags_save_string_array = ndr->flags;
12919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12920                         if (r->dependent_files) {
12921                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
12922                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12923                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
12924                         }
12925                         ndr->flags = _flags_save_string_array;
12926                 }
12927                 {
12928                         uint32_t _flags_save_string = ndr->flags;
12929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12930                         if (r->monitor_name) {
12931                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
12932                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12933                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
12934                         }
12935                         ndr->flags = _flags_save_string;
12936                 }
12937                 {
12938                         uint32_t _flags_save_string = ndr->flags;
12939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12940                         if (r->default_datatype) {
12941                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
12942                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12943                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
12944                         }
12945                         ndr->flags = _flags_save_string;
12946                 }
12947                 {
12948                         uint32_t _flags_save_string_array = ndr->flags;
12949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12950                         if (r->previous_names) {
12951                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
12952                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12953                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
12954                         }
12955                         ndr->flags = _flags_save_string_array;
12956                 }
12957                 {
12958                         uint32_t _flags_save_string = ndr->flags;
12959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12960                         if (r->manufacturer_name) {
12961                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
12962                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12963                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
12964                         }
12965                         ndr->flags = _flags_save_string;
12966                 }
12967                 {
12968                         uint32_t _flags_save_string = ndr->flags;
12969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12970                         if (r->manufacturer_url) {
12971                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
12972                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12973                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
12974                         }
12975                         ndr->flags = _flags_save_string;
12976                 }
12977                 {
12978                         uint32_t _flags_save_string = ndr->flags;
12979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12980                         if (r->hardware_id) {
12981                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
12982                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12983                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
12984                         }
12985                         ndr->flags = _flags_save_string;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->provider) {
12991                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
12992                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12993                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
12994                         }
12995                         ndr->flags = _flags_save_string;
12996                 }
12997         }
12998         return NDR_ERR_SUCCESS;
12999 }
13000
13001 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
13002 {
13003         uint32_t _ptr_driver_name;
13004         TALLOC_CTX *_mem_save_driver_name_0;
13005         uint32_t _ptr_architecture;
13006         TALLOC_CTX *_mem_save_architecture_0;
13007         uint32_t _ptr_driver_path;
13008         TALLOC_CTX *_mem_save_driver_path_0;
13009         uint32_t _ptr_data_file;
13010         TALLOC_CTX *_mem_save_data_file_0;
13011         uint32_t _ptr_config_file;
13012         TALLOC_CTX *_mem_save_config_file_0;
13013         uint32_t _ptr_help_file;
13014         TALLOC_CTX *_mem_save_help_file_0;
13015         uint32_t _ptr_dependent_files;
13016         TALLOC_CTX *_mem_save_dependent_files_0;
13017         uint32_t _ptr_monitor_name;
13018         TALLOC_CTX *_mem_save_monitor_name_0;
13019         uint32_t _ptr_default_datatype;
13020         TALLOC_CTX *_mem_save_default_datatype_0;
13021         uint32_t _ptr_previous_names;
13022         TALLOC_CTX *_mem_save_previous_names_0;
13023         uint32_t _ptr_manufacturer_name;
13024         TALLOC_CTX *_mem_save_manufacturer_name_0;
13025         uint32_t _ptr_manufacturer_url;
13026         TALLOC_CTX *_mem_save_manufacturer_url_0;
13027         uint32_t _ptr_hardware_id;
13028         TALLOC_CTX *_mem_save_hardware_id_0;
13029         uint32_t _ptr_provider;
13030         TALLOC_CTX *_mem_save_provider_0;
13031         if (ndr_flags & NDR_SCALARS) {
13032                 NDR_CHECK(ndr_pull_align(ndr, 8));
13033                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13034                 {
13035                         uint32_t _flags_save_string = ndr->flags;
13036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13037                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13038                         if (_ptr_driver_name) {
13039                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13040                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13041                         } else {
13042                                 r->driver_name = NULL;
13043                         }
13044                         ndr->flags = _flags_save_string;
13045                 }
13046                 {
13047                         uint32_t _flags_save_string = ndr->flags;
13048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13050                         if (_ptr_architecture) {
13051                                 NDR_PULL_ALLOC(ndr, r->architecture);
13052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13053                         } else {
13054                                 r->architecture = NULL;
13055                         }
13056                         ndr->flags = _flags_save_string;
13057                 }
13058                 {
13059                         uint32_t _flags_save_string = ndr->flags;
13060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13061                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13062                         if (_ptr_driver_path) {
13063                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13064                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13065                         } else {
13066                                 r->driver_path = NULL;
13067                         }
13068                         ndr->flags = _flags_save_string;
13069                 }
13070                 {
13071                         uint32_t _flags_save_string = ndr->flags;
13072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13073                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13074                         if (_ptr_data_file) {
13075                                 NDR_PULL_ALLOC(ndr, r->data_file);
13076                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13077                         } else {
13078                                 r->data_file = NULL;
13079                         }
13080                         ndr->flags = _flags_save_string;
13081                 }
13082                 {
13083                         uint32_t _flags_save_string = ndr->flags;
13084                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13085                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13086                         if (_ptr_config_file) {
13087                                 NDR_PULL_ALLOC(ndr, r->config_file);
13088                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13089                         } else {
13090                                 r->config_file = NULL;
13091                         }
13092                         ndr->flags = _flags_save_string;
13093                 }
13094                 {
13095                         uint32_t _flags_save_string = ndr->flags;
13096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13097                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13098                         if (_ptr_help_file) {
13099                                 NDR_PULL_ALLOC(ndr, r->help_file);
13100                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13101                         } else {
13102                                 r->help_file = NULL;
13103                         }
13104                         ndr->flags = _flags_save_string;
13105                 }
13106                 {
13107                         uint32_t _flags_save_string_array = ndr->flags;
13108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13110                         if (_ptr_dependent_files) {
13111                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13113                         } else {
13114                                 r->dependent_files = NULL;
13115                         }
13116                         ndr->flags = _flags_save_string_array;
13117                 }
13118                 {
13119                         uint32_t _flags_save_string = ndr->flags;
13120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13122                         if (_ptr_monitor_name) {
13123                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13125                         } else {
13126                                 r->monitor_name = NULL;
13127                         }
13128                         ndr->flags = _flags_save_string;
13129                 }
13130                 {
13131                         uint32_t _flags_save_string = ndr->flags;
13132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13133                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13134                         if (_ptr_default_datatype) {
13135                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13136                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13137                         } else {
13138                                 r->default_datatype = NULL;
13139                         }
13140                         ndr->flags = _flags_save_string;
13141                 }
13142                 {
13143                         uint32_t _flags_save_string_array = ndr->flags;
13144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13145                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13146                         if (_ptr_previous_names) {
13147                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13148                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13149                         } else {
13150                                 r->previous_names = NULL;
13151                         }
13152                         ndr->flags = _flags_save_string_array;
13153                 }
13154                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13155                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13156                 {
13157                         uint32_t _flags_save_string = ndr->flags;
13158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13159                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13160                         if (_ptr_manufacturer_name) {
13161                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13162                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13163                         } else {
13164                                 r->manufacturer_name = NULL;
13165                         }
13166                         ndr->flags = _flags_save_string;
13167                 }
13168                 {
13169                         uint32_t _flags_save_string = ndr->flags;
13170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13171                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13172                         if (_ptr_manufacturer_url) {
13173                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13174                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13175                         } else {
13176                                 r->manufacturer_url = NULL;
13177                         }
13178                         ndr->flags = _flags_save_string;
13179                 }
13180                 {
13181                         uint32_t _flags_save_string = ndr->flags;
13182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13183                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13184                         if (_ptr_hardware_id) {
13185                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13186                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13187                         } else {
13188                                 r->hardware_id = NULL;
13189                         }
13190                         ndr->flags = _flags_save_string;
13191                 }
13192                 {
13193                         uint32_t _flags_save_string = ndr->flags;
13194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13196                         if (_ptr_provider) {
13197                                 NDR_PULL_ALLOC(ndr, r->provider);
13198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13199                         } else {
13200                                 r->provider = NULL;
13201                         }
13202                         ndr->flags = _flags_save_string;
13203                 }
13204                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13205         }
13206         if (ndr_flags & NDR_BUFFERS) {
13207                 {
13208                         uint32_t _flags_save_string = ndr->flags;
13209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13210                         if (r->driver_name) {
13211                                 uint32_t _relative_save_offset;
13212                                 _relative_save_offset = ndr->offset;
13213                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13214                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13215                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13216                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13217                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13218                                 if (ndr->offset > ndr->relative_highest_offset) {
13219                                         ndr->relative_highest_offset = ndr->offset;
13220                                 }
13221                                 ndr->offset = _relative_save_offset;
13222                         }
13223                         ndr->flags = _flags_save_string;
13224                 }
13225                 {
13226                         uint32_t _flags_save_string = ndr->flags;
13227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13228                         if (r->architecture) {
13229                                 uint32_t _relative_save_offset;
13230                                 _relative_save_offset = ndr->offset;
13231                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13232                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13233                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13234                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13235                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13236                                 if (ndr->offset > ndr->relative_highest_offset) {
13237                                         ndr->relative_highest_offset = ndr->offset;
13238                                 }
13239                                 ndr->offset = _relative_save_offset;
13240                         }
13241                         ndr->flags = _flags_save_string;
13242                 }
13243                 {
13244                         uint32_t _flags_save_string = ndr->flags;
13245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13246                         if (r->driver_path) {
13247                                 uint32_t _relative_save_offset;
13248                                 _relative_save_offset = ndr->offset;
13249                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13250                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13251                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13252                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13253                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13254                                 if (ndr->offset > ndr->relative_highest_offset) {
13255                                         ndr->relative_highest_offset = ndr->offset;
13256                                 }
13257                                 ndr->offset = _relative_save_offset;
13258                         }
13259                         ndr->flags = _flags_save_string;
13260                 }
13261                 {
13262                         uint32_t _flags_save_string = ndr->flags;
13263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13264                         if (r->data_file) {
13265                                 uint32_t _relative_save_offset;
13266                                 _relative_save_offset = ndr->offset;
13267                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13268                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13269                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13270                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13271                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13272                                 if (ndr->offset > ndr->relative_highest_offset) {
13273                                         ndr->relative_highest_offset = ndr->offset;
13274                                 }
13275                                 ndr->offset = _relative_save_offset;
13276                         }
13277                         ndr->flags = _flags_save_string;
13278                 }
13279                 {
13280                         uint32_t _flags_save_string = ndr->flags;
13281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13282                         if (r->config_file) {
13283                                 uint32_t _relative_save_offset;
13284                                 _relative_save_offset = ndr->offset;
13285                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
13286                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13287                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
13288                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
13289                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
13290                                 if (ndr->offset > ndr->relative_highest_offset) {
13291                                         ndr->relative_highest_offset = ndr->offset;
13292                                 }
13293                                 ndr->offset = _relative_save_offset;
13294                         }
13295                         ndr->flags = _flags_save_string;
13296                 }
13297                 {
13298                         uint32_t _flags_save_string = ndr->flags;
13299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13300                         if (r->help_file) {
13301                                 uint32_t _relative_save_offset;
13302                                 _relative_save_offset = ndr->offset;
13303                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
13304                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13305                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
13306                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
13307                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
13308                                 if (ndr->offset > ndr->relative_highest_offset) {
13309                                         ndr->relative_highest_offset = ndr->offset;
13310                                 }
13311                                 ndr->offset = _relative_save_offset;
13312                         }
13313                         ndr->flags = _flags_save_string;
13314                 }
13315                 {
13316                         uint32_t _flags_save_string_array = ndr->flags;
13317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13318                         if (r->dependent_files) {
13319                                 uint32_t _relative_save_offset;
13320                                 _relative_save_offset = ndr->offset;
13321                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
13322                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
13323                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
13324                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
13325                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
13326                                 if (ndr->offset > ndr->relative_highest_offset) {
13327                                         ndr->relative_highest_offset = ndr->offset;
13328                                 }
13329                                 ndr->offset = _relative_save_offset;
13330                         }
13331                         ndr->flags = _flags_save_string_array;
13332                 }
13333                 {
13334                         uint32_t _flags_save_string = ndr->flags;
13335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13336                         if (r->monitor_name) {
13337                                 uint32_t _relative_save_offset;
13338                                 _relative_save_offset = ndr->offset;
13339                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
13340                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13341                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
13342                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
13343                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
13344                                 if (ndr->offset > ndr->relative_highest_offset) {
13345                                         ndr->relative_highest_offset = ndr->offset;
13346                                 }
13347                                 ndr->offset = _relative_save_offset;
13348                         }
13349                         ndr->flags = _flags_save_string;
13350                 }
13351                 {
13352                         uint32_t _flags_save_string = ndr->flags;
13353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13354                         if (r->default_datatype) {
13355                                 uint32_t _relative_save_offset;
13356                                 _relative_save_offset = ndr->offset;
13357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
13358                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
13359                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
13360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
13361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
13362                                 if (ndr->offset > ndr->relative_highest_offset) {
13363                                         ndr->relative_highest_offset = ndr->offset;
13364                                 }
13365                                 ndr->offset = _relative_save_offset;
13366                         }
13367                         ndr->flags = _flags_save_string;
13368                 }
13369                 {
13370                         uint32_t _flags_save_string_array = ndr->flags;
13371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13372                         if (r->previous_names) {
13373                                 uint32_t _relative_save_offset;
13374                                 _relative_save_offset = ndr->offset;
13375                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13376                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13377                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13378                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13379                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13380                                 if (ndr->offset > ndr->relative_highest_offset) {
13381                                         ndr->relative_highest_offset = ndr->offset;
13382                                 }
13383                                 ndr->offset = _relative_save_offset;
13384                         }
13385                         ndr->flags = _flags_save_string_array;
13386                 }
13387                 {
13388                         uint32_t _flags_save_string = ndr->flags;
13389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13390                         if (r->manufacturer_name) {
13391                                 uint32_t _relative_save_offset;
13392                                 _relative_save_offset = ndr->offset;
13393                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13394                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13395                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13396                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13397                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13398                                 if (ndr->offset > ndr->relative_highest_offset) {
13399                                         ndr->relative_highest_offset = ndr->offset;
13400                                 }
13401                                 ndr->offset = _relative_save_offset;
13402                         }
13403                         ndr->flags = _flags_save_string;
13404                 }
13405                 {
13406                         uint32_t _flags_save_string = ndr->flags;
13407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13408                         if (r->manufacturer_url) {
13409                                 uint32_t _relative_save_offset;
13410                                 _relative_save_offset = ndr->offset;
13411                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13412                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13413                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13414                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13415                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13416                                 if (ndr->offset > ndr->relative_highest_offset) {
13417                                         ndr->relative_highest_offset = ndr->offset;
13418                                 }
13419                                 ndr->offset = _relative_save_offset;
13420                         }
13421                         ndr->flags = _flags_save_string;
13422                 }
13423                 {
13424                         uint32_t _flags_save_string = ndr->flags;
13425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13426                         if (r->hardware_id) {
13427                                 uint32_t _relative_save_offset;
13428                                 _relative_save_offset = ndr->offset;
13429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13430                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13431                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13434                                 if (ndr->offset > ndr->relative_highest_offset) {
13435                                         ndr->relative_highest_offset = ndr->offset;
13436                                 }
13437                                 ndr->offset = _relative_save_offset;
13438                         }
13439                         ndr->flags = _flags_save_string;
13440                 }
13441                 {
13442                         uint32_t _flags_save_string = ndr->flags;
13443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13444                         if (r->provider) {
13445                                 uint32_t _relative_save_offset;
13446                                 _relative_save_offset = ndr->offset;
13447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13448                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13449                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13452                                 if (ndr->offset > ndr->relative_highest_offset) {
13453                                         ndr->relative_highest_offset = ndr->offset;
13454                                 }
13455                                 ndr->offset = _relative_save_offset;
13456                         }
13457                         ndr->flags = _flags_save_string;
13458                 }
13459         }
13460         return NDR_ERR_SUCCESS;
13461 }
13462
13463 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13464 {
13465         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13466         ndr->depth++;
13467         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13468         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13469         ndr->depth++;
13470         if (r->driver_name) {
13471                 ndr_print_string(ndr, "driver_name", r->driver_name);
13472         }
13473         ndr->depth--;
13474         ndr_print_ptr(ndr, "architecture", r->architecture);
13475         ndr->depth++;
13476         if (r->architecture) {
13477                 ndr_print_string(ndr, "architecture", r->architecture);
13478         }
13479         ndr->depth--;
13480         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13481         ndr->depth++;
13482         if (r->driver_path) {
13483                 ndr_print_string(ndr, "driver_path", r->driver_path);
13484         }
13485         ndr->depth--;
13486         ndr_print_ptr(ndr, "data_file", r->data_file);
13487         ndr->depth++;
13488         if (r->data_file) {
13489                 ndr_print_string(ndr, "data_file", r->data_file);
13490         }
13491         ndr->depth--;
13492         ndr_print_ptr(ndr, "config_file", r->config_file);
13493         ndr->depth++;
13494         if (r->config_file) {
13495                 ndr_print_string(ndr, "config_file", r->config_file);
13496         }
13497         ndr->depth--;
13498         ndr_print_ptr(ndr, "help_file", r->help_file);
13499         ndr->depth++;
13500         if (r->help_file) {
13501                 ndr_print_string(ndr, "help_file", r->help_file);
13502         }
13503         ndr->depth--;
13504         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13505         ndr->depth++;
13506         if (r->dependent_files) {
13507                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13508         }
13509         ndr->depth--;
13510         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13511         ndr->depth++;
13512         if (r->monitor_name) {
13513                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13514         }
13515         ndr->depth--;
13516         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13517         ndr->depth++;
13518         if (r->default_datatype) {
13519                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13520         }
13521         ndr->depth--;
13522         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13523         ndr->depth++;
13524         if (r->previous_names) {
13525                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13526         }
13527         ndr->depth--;
13528         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13529         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13530         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13531         ndr->depth++;
13532         if (r->manufacturer_name) {
13533                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13534         }
13535         ndr->depth--;
13536         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13537         ndr->depth++;
13538         if (r->manufacturer_url) {
13539                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13540         }
13541         ndr->depth--;
13542         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13543         ndr->depth++;
13544         if (r->hardware_id) {
13545                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13546         }
13547         ndr->depth--;
13548         ndr_print_ptr(ndr, "provider", r->provider);
13549         ndr->depth++;
13550         if (r->provider) {
13551                 ndr_print_string(ndr, "provider", r->provider);
13552         }
13553         ndr->depth--;
13554         ndr->depth--;
13555 }
13556
13557 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13558 {
13559         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13560 }
13561
13562 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13563 {
13564         if (ndr_flags & NDR_SCALARS) {
13565                 NDR_CHECK(ndr_push_align(ndr, 5));
13566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13567                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13568                 {
13569                         uint32_t _flags_save_string = ndr->flags;
13570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13572                         ndr->flags = _flags_save_string;
13573                 }
13574                 {
13575                         uint32_t _flags_save_string = ndr->flags;
13576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13578                         ndr->flags = _flags_save_string;
13579                 }
13580                 {
13581                         uint32_t _flags_save_string = ndr->flags;
13582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13584                         ndr->flags = _flags_save_string;
13585                 }
13586                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13587         }
13588         if (ndr_flags & NDR_BUFFERS) {
13589                 {
13590                         uint32_t _flags_save_string = ndr->flags;
13591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13592                         if (r->driver_name) {
13593                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13595                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13596                         }
13597                         ndr->flags = _flags_save_string;
13598                 }
13599                 {
13600                         uint32_t _flags_save_string = ndr->flags;
13601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13602                         if (r->inf_name) {
13603                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_name));
13604                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13605                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_name));
13606                         }
13607                         ndr->flags = _flags_save_string;
13608                 }
13609                 {
13610                         uint32_t _flags_save_string = ndr->flags;
13611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13612                         if (r->install_source_root) {
13613                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->install_source_root));
13614                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13615                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->install_source_root));
13616                         }
13617                         ndr->flags = _flags_save_string;
13618                 }
13619         }
13620         return NDR_ERR_SUCCESS;
13621 }
13622
13623 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13624 {
13625         uint32_t _ptr_driver_name;
13626         TALLOC_CTX *_mem_save_driver_name_0;
13627         uint32_t _ptr_inf_name;
13628         TALLOC_CTX *_mem_save_inf_name_0;
13629         uint32_t _ptr_install_source_root;
13630         TALLOC_CTX *_mem_save_install_source_root_0;
13631         if (ndr_flags & NDR_SCALARS) {
13632                 NDR_CHECK(ndr_pull_align(ndr, 5));
13633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13634                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13635                 {
13636                         uint32_t _flags_save_string = ndr->flags;
13637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13638                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13639                         if (_ptr_driver_name) {
13640                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13641                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13642                         } else {
13643                                 r->driver_name = NULL;
13644                         }
13645                         ndr->flags = _flags_save_string;
13646                 }
13647                 {
13648                         uint32_t _flags_save_string = ndr->flags;
13649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13650                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13651                         if (_ptr_inf_name) {
13652                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13653                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13654                         } else {
13655                                 r->inf_name = NULL;
13656                         }
13657                         ndr->flags = _flags_save_string;
13658                 }
13659                 {
13660                         uint32_t _flags_save_string = ndr->flags;
13661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13663                         if (_ptr_install_source_root) {
13664                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13665                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13666                         } else {
13667                                 r->install_source_root = NULL;
13668                         }
13669                         ndr->flags = _flags_save_string;
13670                 }
13671                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13672         }
13673         if (ndr_flags & NDR_BUFFERS) {
13674                 {
13675                         uint32_t _flags_save_string = ndr->flags;
13676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13677                         if (r->driver_name) {
13678                                 uint32_t _relative_save_offset;
13679                                 _relative_save_offset = ndr->offset;
13680                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13681                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13682                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13683                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13684                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13685                                 if (ndr->offset > ndr->relative_highest_offset) {
13686                                         ndr->relative_highest_offset = ndr->offset;
13687                                 }
13688                                 ndr->offset = _relative_save_offset;
13689                         }
13690                         ndr->flags = _flags_save_string;
13691                 }
13692                 {
13693                         uint32_t _flags_save_string = ndr->flags;
13694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13695                         if (r->inf_name) {
13696                                 uint32_t _relative_save_offset;
13697                                 _relative_save_offset = ndr->offset;
13698                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13699                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13700                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13701                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13702                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13703                                 if (ndr->offset > ndr->relative_highest_offset) {
13704                                         ndr->relative_highest_offset = ndr->offset;
13705                                 }
13706                                 ndr->offset = _relative_save_offset;
13707                         }
13708                         ndr->flags = _flags_save_string;
13709                 }
13710                 {
13711                         uint32_t _flags_save_string = ndr->flags;
13712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13713                         if (r->install_source_root) {
13714                                 uint32_t _relative_save_offset;
13715                                 _relative_save_offset = ndr->offset;
13716                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13717                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13718                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13719                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13720                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13721                                 if (ndr->offset > ndr->relative_highest_offset) {
13722                                         ndr->relative_highest_offset = ndr->offset;
13723                                 }
13724                                 ndr->offset = _relative_save_offset;
13725                         }
13726                         ndr->flags = _flags_save_string;
13727                 }
13728         }
13729         return NDR_ERR_SUCCESS;
13730 }
13731
13732 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13733 {
13734         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13735         ndr->depth++;
13736         ndr_print_uint32(ndr, "size", r->size);
13737         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13738         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13739         ndr->depth++;
13740         if (r->driver_name) {
13741                 ndr_print_string(ndr, "driver_name", r->driver_name);
13742         }
13743         ndr->depth--;
13744         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13745         ndr->depth++;
13746         if (r->inf_name) {
13747                 ndr_print_string(ndr, "inf_name", r->inf_name);
13748         }
13749         ndr->depth--;
13750         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13751         ndr->depth++;
13752         if (r->install_source_root) {
13753                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13754         }
13755         ndr->depth--;
13756         ndr->depth--;
13757 }
13758
13759 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13760 {
13761         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13762 }
13763
13764 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13765 {
13766         if (ndr_flags & NDR_SCALARS) {
13767                 NDR_CHECK(ndr_push_align(ndr, 8));
13768                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13769                 {
13770                         uint32_t _flags_save_string = ndr->flags;
13771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13772                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13773                         ndr->flags = _flags_save_string;
13774                 }
13775                 {
13776                         uint32_t _flags_save_string = ndr->flags;
13777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13778                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13779                         ndr->flags = _flags_save_string;
13780                 }
13781                 {
13782                         uint32_t _flags_save_string = ndr->flags;
13783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13784                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13785                         ndr->flags = _flags_save_string;
13786                 }
13787                 {
13788                         uint32_t _flags_save_string = ndr->flags;
13789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13790                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13791                         ndr->flags = _flags_save_string;
13792                 }
13793                 {
13794                         uint32_t _flags_save_string = ndr->flags;
13795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13796                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13797                         ndr->flags = _flags_save_string;
13798                 }
13799                 {
13800                         uint32_t _flags_save_string = ndr->flags;
13801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13802                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13803                         ndr->flags = _flags_save_string;
13804                 }
13805                 {
13806                         uint32_t _flags_save_string_array = ndr->flags;
13807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13808                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13809                         ndr->flags = _flags_save_string_array;
13810                 }
13811                 {
13812                         uint32_t _flags_save_string = ndr->flags;
13813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13814                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13815                         ndr->flags = _flags_save_string;
13816                 }
13817                 {
13818                         uint32_t _flags_save_string = ndr->flags;
13819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13820                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13821                         ndr->flags = _flags_save_string;
13822                 }
13823                 {
13824                         uint32_t _flags_save_string_array = ndr->flags;
13825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13826                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13827                         ndr->flags = _flags_save_string_array;
13828                 }
13829                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13830                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13831                 {
13832                         uint32_t _flags_save_string = ndr->flags;
13833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13834                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13835                         ndr->flags = _flags_save_string;
13836                 }
13837                 {
13838                         uint32_t _flags_save_string = ndr->flags;
13839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13840                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13841                         ndr->flags = _flags_save_string;
13842                 }
13843                 {
13844                         uint32_t _flags_save_string = ndr->flags;
13845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13846                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13847                         ndr->flags = _flags_save_string;
13848                 }
13849                 {
13850                         uint32_t _flags_save_string = ndr->flags;
13851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13853                         ndr->flags = _flags_save_string;
13854                 }
13855                 {
13856                         uint32_t _flags_save_string = ndr->flags;
13857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13859                         ndr->flags = _flags_save_string;
13860                 }
13861                 {
13862                         uint32_t _flags_save_string = ndr->flags;
13863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13864                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13865                         ndr->flags = _flags_save_string;
13866                 }
13867                 {
13868                         uint32_t _flags_save_string_array = ndr->flags;
13869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13870                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13871                         ndr->flags = _flags_save_string_array;
13872                 }
13873                 {
13874                         uint32_t _flags_save_string = ndr->flags;
13875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13876                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13877                         ndr->flags = _flags_save_string;
13878                 }
13879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13880                 {
13881                         uint32_t _flags_save_string_array = ndr->flags;
13882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13883                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13884                         ndr->flags = _flags_save_string_array;
13885                 }
13886                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13887                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13888                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13889         }
13890         if (ndr_flags & NDR_BUFFERS) {
13891                 {
13892                         uint32_t _flags_save_string = ndr->flags;
13893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13894                         if (r->driver_name) {
13895                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
13896                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13897                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
13898                         }
13899                         ndr->flags = _flags_save_string;
13900                 }
13901                 {
13902                         uint32_t _flags_save_string = ndr->flags;
13903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13904                         if (r->architecture) {
13905                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
13906                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13907                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
13908                         }
13909                         ndr->flags = _flags_save_string;
13910                 }
13911                 {
13912                         uint32_t _flags_save_string = ndr->flags;
13913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13914                         if (r->driver_path) {
13915                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_path));
13916                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13917                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_path));
13918                         }
13919                         ndr->flags = _flags_save_string;
13920                 }
13921                 {
13922                         uint32_t _flags_save_string = ndr->flags;
13923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13924                         if (r->data_file) {
13925                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data_file));
13926                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13927                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data_file));
13928                         }
13929                         ndr->flags = _flags_save_string;
13930                 }
13931                 {
13932                         uint32_t _flags_save_string = ndr->flags;
13933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13934                         if (r->config_file) {
13935                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->config_file));
13936                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13937                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->config_file));
13938                         }
13939                         ndr->flags = _flags_save_string;
13940                 }
13941                 {
13942                         uint32_t _flags_save_string = ndr->flags;
13943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13944                         if (r->help_file) {
13945                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->help_file));
13946                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13947                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->help_file));
13948                         }
13949                         ndr->flags = _flags_save_string;
13950                 }
13951                 {
13952                         uint32_t _flags_save_string_array = ndr->flags;
13953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13954                         if (r->dependent_files) {
13955                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dependent_files));
13956                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13957                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dependent_files));
13958                         }
13959                         ndr->flags = _flags_save_string_array;
13960                 }
13961                 {
13962                         uint32_t _flags_save_string = ndr->flags;
13963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13964                         if (r->monitor_name) {
13965                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
13966                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13967                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
13968                         }
13969                         ndr->flags = _flags_save_string;
13970                 }
13971                 {
13972                         uint32_t _flags_save_string = ndr->flags;
13973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13974                         if (r->default_datatype) {
13975                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
13976                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13977                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
13978                         }
13979                         ndr->flags = _flags_save_string;
13980                 }
13981                 {
13982                         uint32_t _flags_save_string_array = ndr->flags;
13983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13984                         if (r->previous_names) {
13985                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
13986                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13987                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
13988                         }
13989                         ndr->flags = _flags_save_string_array;
13990                 }
13991                 {
13992                         uint32_t _flags_save_string = ndr->flags;
13993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13994                         if (r->manufacturer_name) {
13995                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
13996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13997                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
13998                         }
13999                         ndr->flags = _flags_save_string;
14000                 }
14001                 {
14002                         uint32_t _flags_save_string = ndr->flags;
14003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14004                         if (r->manufacturer_url) {
14005                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
14006                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
14007                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
14008                         }
14009                         ndr->flags = _flags_save_string;
14010                 }
14011                 {
14012                         uint32_t _flags_save_string = ndr->flags;
14013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14014                         if (r->hardware_id) {
14015                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
14016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
14017                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
14018                         }
14019                         ndr->flags = _flags_save_string;
14020                 }
14021                 {
14022                         uint32_t _flags_save_string = ndr->flags;
14023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14024                         if (r->provider) {
14025                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
14026                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
14027                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
14028                         }
14029                         ndr->flags = _flags_save_string;
14030                 }
14031                 {
14032                         uint32_t _flags_save_string = ndr->flags;
14033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14034                         if (r->print_processor) {
14035                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor));
14036                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
14037                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor));
14038                         }
14039                         ndr->flags = _flags_save_string;
14040                 }
14041                 {
14042                         uint32_t _flags_save_string = ndr->flags;
14043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14044                         if (r->vendor_setup) {
14045                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->vendor_setup));
14046                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
14047                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->vendor_setup));
14048                         }
14049                         ndr->flags = _flags_save_string;
14050                 }
14051                 {
14052                         uint32_t _flags_save_string_array = ndr->flags;
14053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14054                         if (r->color_profiles) {
14055                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->color_profiles));
14056                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
14057                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->color_profiles));
14058                         }
14059                         ndr->flags = _flags_save_string_array;
14060                 }
14061                 {
14062                         uint32_t _flags_save_string = ndr->flags;
14063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14064                         if (r->inf_path) {
14065                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->inf_path));
14066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
14067                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->inf_path));
14068                         }
14069                         ndr->flags = _flags_save_string;
14070                 }
14071                 {
14072                         uint32_t _flags_save_string_array = ndr->flags;
14073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14074                         if (r->core_driver_dependencies) {
14075                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->core_driver_dependencies));
14076                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
14077                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->core_driver_dependencies));
14078                         }
14079                         ndr->flags = _flags_save_string_array;
14080                 }
14081         }
14082         return NDR_ERR_SUCCESS;
14083 }
14084
14085 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
14086 {
14087         uint32_t _ptr_driver_name;
14088         TALLOC_CTX *_mem_save_driver_name_0;
14089         uint32_t _ptr_architecture;
14090         TALLOC_CTX *_mem_save_architecture_0;
14091         uint32_t _ptr_driver_path;
14092         TALLOC_CTX *_mem_save_driver_path_0;
14093         uint32_t _ptr_data_file;
14094         TALLOC_CTX *_mem_save_data_file_0;
14095         uint32_t _ptr_config_file;
14096         TALLOC_CTX *_mem_save_config_file_0;
14097         uint32_t _ptr_help_file;
14098         TALLOC_CTX *_mem_save_help_file_0;
14099         uint32_t _ptr_dependent_files;
14100         TALLOC_CTX *_mem_save_dependent_files_0;
14101         uint32_t _ptr_monitor_name;
14102         TALLOC_CTX *_mem_save_monitor_name_0;
14103         uint32_t _ptr_default_datatype;
14104         TALLOC_CTX *_mem_save_default_datatype_0;
14105         uint32_t _ptr_previous_names;
14106         TALLOC_CTX *_mem_save_previous_names_0;
14107         uint32_t _ptr_manufacturer_name;
14108         TALLOC_CTX *_mem_save_manufacturer_name_0;
14109         uint32_t _ptr_manufacturer_url;
14110         TALLOC_CTX *_mem_save_manufacturer_url_0;
14111         uint32_t _ptr_hardware_id;
14112         TALLOC_CTX *_mem_save_hardware_id_0;
14113         uint32_t _ptr_provider;
14114         TALLOC_CTX *_mem_save_provider_0;
14115         uint32_t _ptr_print_processor;
14116         TALLOC_CTX *_mem_save_print_processor_0;
14117         uint32_t _ptr_vendor_setup;
14118         TALLOC_CTX *_mem_save_vendor_setup_0;
14119         uint32_t _ptr_color_profiles;
14120         TALLOC_CTX *_mem_save_color_profiles_0;
14121         uint32_t _ptr_inf_path;
14122         TALLOC_CTX *_mem_save_inf_path_0;
14123         uint32_t _ptr_core_driver_dependencies;
14124         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
14125         if (ndr_flags & NDR_SCALARS) {
14126                 NDR_CHECK(ndr_pull_align(ndr, 8));
14127                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
14128                 {
14129                         uint32_t _flags_save_string = ndr->flags;
14130                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14131                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
14132                         if (_ptr_driver_name) {
14133                                 NDR_PULL_ALLOC(ndr, r->driver_name);
14134                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
14135                         } else {
14136                                 r->driver_name = NULL;
14137                         }
14138                         ndr->flags = _flags_save_string;
14139                 }
14140                 {
14141                         uint32_t _flags_save_string = ndr->flags;
14142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14143                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
14144                         if (_ptr_architecture) {
14145                                 NDR_PULL_ALLOC(ndr, r->architecture);
14146                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
14147                         } else {
14148                                 r->architecture = NULL;
14149                         }
14150                         ndr->flags = _flags_save_string;
14151                 }
14152                 {
14153                         uint32_t _flags_save_string = ndr->flags;
14154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14155                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
14156                         if (_ptr_driver_path) {
14157                                 NDR_PULL_ALLOC(ndr, r->driver_path);
14158                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
14159                         } else {
14160                                 r->driver_path = NULL;
14161                         }
14162                         ndr->flags = _flags_save_string;
14163                 }
14164                 {
14165                         uint32_t _flags_save_string = ndr->flags;
14166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14167                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
14168                         if (_ptr_data_file) {
14169                                 NDR_PULL_ALLOC(ndr, r->data_file);
14170                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
14171                         } else {
14172                                 r->data_file = NULL;
14173                         }
14174                         ndr->flags = _flags_save_string;
14175                 }
14176                 {
14177                         uint32_t _flags_save_string = ndr->flags;
14178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14179                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
14180                         if (_ptr_config_file) {
14181                                 NDR_PULL_ALLOC(ndr, r->config_file);
14182                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
14183                         } else {
14184                                 r->config_file = NULL;
14185                         }
14186                         ndr->flags = _flags_save_string;
14187                 }
14188                 {
14189                         uint32_t _flags_save_string = ndr->flags;
14190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14191                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
14192                         if (_ptr_help_file) {
14193                                 NDR_PULL_ALLOC(ndr, r->help_file);
14194                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
14195                         } else {
14196                                 r->help_file = NULL;
14197                         }
14198                         ndr->flags = _flags_save_string;
14199                 }
14200                 {
14201                         uint32_t _flags_save_string_array = ndr->flags;
14202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14203                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
14204                         if (_ptr_dependent_files) {
14205                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
14206                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
14207                         } else {
14208                                 r->dependent_files = NULL;
14209                         }
14210                         ndr->flags = _flags_save_string_array;
14211                 }
14212                 {
14213                         uint32_t _flags_save_string = ndr->flags;
14214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14215                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
14216                         if (_ptr_monitor_name) {
14217                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
14218                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
14219                         } else {
14220                                 r->monitor_name = NULL;
14221                         }
14222                         ndr->flags = _flags_save_string;
14223                 }
14224                 {
14225                         uint32_t _flags_save_string = ndr->flags;
14226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14227                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
14228                         if (_ptr_default_datatype) {
14229                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
14230                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
14231                         } else {
14232                                 r->default_datatype = NULL;
14233                         }
14234                         ndr->flags = _flags_save_string;
14235                 }
14236                 {
14237                         uint32_t _flags_save_string_array = ndr->flags;
14238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14239                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
14240                         if (_ptr_previous_names) {
14241                                 NDR_PULL_ALLOC(ndr, r->previous_names);
14242                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
14243                         } else {
14244                                 r->previous_names = NULL;
14245                         }
14246                         ndr->flags = _flags_save_string_array;
14247                 }
14248                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
14249                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
14250                 {
14251                         uint32_t _flags_save_string = ndr->flags;
14252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14253                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
14254                         if (_ptr_manufacturer_name) {
14255                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
14256                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
14257                         } else {
14258                                 r->manufacturer_name = NULL;
14259                         }
14260                         ndr->flags = _flags_save_string;
14261                 }
14262                 {
14263                         uint32_t _flags_save_string = ndr->flags;
14264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14265                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
14266                         if (_ptr_manufacturer_url) {
14267                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
14268                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
14269                         } else {
14270                                 r->manufacturer_url = NULL;
14271                         }
14272                         ndr->flags = _flags_save_string;
14273                 }
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_hardware_id));
14278                         if (_ptr_hardware_id) {
14279                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
14280                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
14281                         } else {
14282                                 r->hardware_id = NULL;
14283                         }
14284                         ndr->flags = _flags_save_string;
14285                 }
14286                 {
14287                         uint32_t _flags_save_string = ndr->flags;
14288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14289                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
14290                         if (_ptr_provider) {
14291                                 NDR_PULL_ALLOC(ndr, r->provider);
14292                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
14293                         } else {
14294                                 r->provider = NULL;
14295                         }
14296                         ndr->flags = _flags_save_string;
14297                 }
14298                 {
14299                         uint32_t _flags_save_string = ndr->flags;
14300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14301                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
14302                         if (_ptr_print_processor) {
14303                                 NDR_PULL_ALLOC(ndr, r->print_processor);
14304                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
14305                         } else {
14306                                 r->print_processor = NULL;
14307                         }
14308                         ndr->flags = _flags_save_string;
14309                 }
14310                 {
14311                         uint32_t _flags_save_string = ndr->flags;
14312                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14313                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
14314                         if (_ptr_vendor_setup) {
14315                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
14316                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
14317                         } else {
14318                                 r->vendor_setup = NULL;
14319                         }
14320                         ndr->flags = _flags_save_string;
14321                 }
14322                 {
14323                         uint32_t _flags_save_string_array = ndr->flags;
14324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14325                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
14326                         if (_ptr_color_profiles) {
14327                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
14328                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
14329                         } else {
14330                                 r->color_profiles = NULL;
14331                         }
14332                         ndr->flags = _flags_save_string_array;
14333                 }
14334                 {
14335                         uint32_t _flags_save_string = ndr->flags;
14336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14337                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
14338                         if (_ptr_inf_path) {
14339                                 NDR_PULL_ALLOC(ndr, r->inf_path);
14340                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
14341                         } else {
14342                                 r->inf_path = NULL;
14343                         }
14344                         ndr->flags = _flags_save_string;
14345                 }
14346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
14347                 {
14348                         uint32_t _flags_save_string_array = ndr->flags;
14349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14350                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
14351                         if (_ptr_core_driver_dependencies) {
14352                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
14353                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
14354                         } else {
14355                                 r->core_driver_dependencies = NULL;
14356                         }
14357                         ndr->flags = _flags_save_string_array;
14358                 }
14359                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
14360                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
14361                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
14362         }
14363         if (ndr_flags & NDR_BUFFERS) {
14364                 {
14365                         uint32_t _flags_save_string = ndr->flags;
14366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14367                         if (r->driver_name) {
14368                                 uint32_t _relative_save_offset;
14369                                 _relative_save_offset = ndr->offset;
14370                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
14371                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14372                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
14373                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
14374                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
14375                                 if (ndr->offset > ndr->relative_highest_offset) {
14376                                         ndr->relative_highest_offset = ndr->offset;
14377                                 }
14378                                 ndr->offset = _relative_save_offset;
14379                         }
14380                         ndr->flags = _flags_save_string;
14381                 }
14382                 {
14383                         uint32_t _flags_save_string = ndr->flags;
14384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14385                         if (r->architecture) {
14386                                 uint32_t _relative_save_offset;
14387                                 _relative_save_offset = ndr->offset;
14388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
14389                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
14390                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
14391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
14392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
14393                                 if (ndr->offset > ndr->relative_highest_offset) {
14394                                         ndr->relative_highest_offset = ndr->offset;
14395                                 }
14396                                 ndr->offset = _relative_save_offset;
14397                         }
14398                         ndr->flags = _flags_save_string;
14399                 }
14400                 {
14401                         uint32_t _flags_save_string = ndr->flags;
14402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14403                         if (r->driver_path) {
14404                                 uint32_t _relative_save_offset;
14405                                 _relative_save_offset = ndr->offset;
14406                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
14407                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14408                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
14409                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
14410                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
14411                                 if (ndr->offset > ndr->relative_highest_offset) {
14412                                         ndr->relative_highest_offset = ndr->offset;
14413                                 }
14414                                 ndr->offset = _relative_save_offset;
14415                         }
14416                         ndr->flags = _flags_save_string;
14417                 }
14418                 {
14419                         uint32_t _flags_save_string = ndr->flags;
14420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14421                         if (r->data_file) {
14422                                 uint32_t _relative_save_offset;
14423                                 _relative_save_offset = ndr->offset;
14424                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
14425                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14426                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
14427                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
14428                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
14429                                 if (ndr->offset > ndr->relative_highest_offset) {
14430                                         ndr->relative_highest_offset = ndr->offset;
14431                                 }
14432                                 ndr->offset = _relative_save_offset;
14433                         }
14434                         ndr->flags = _flags_save_string;
14435                 }
14436                 {
14437                         uint32_t _flags_save_string = ndr->flags;
14438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14439                         if (r->config_file) {
14440                                 uint32_t _relative_save_offset;
14441                                 _relative_save_offset = ndr->offset;
14442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14443                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14444                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14445                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14447                                 if (ndr->offset > ndr->relative_highest_offset) {
14448                                         ndr->relative_highest_offset = ndr->offset;
14449                                 }
14450                                 ndr->offset = _relative_save_offset;
14451                         }
14452                         ndr->flags = _flags_save_string;
14453                 }
14454                 {
14455                         uint32_t _flags_save_string = ndr->flags;
14456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14457                         if (r->help_file) {
14458                                 uint32_t _relative_save_offset;
14459                                 _relative_save_offset = ndr->offset;
14460                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14461                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14462                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14463                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14464                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14465                                 if (ndr->offset > ndr->relative_highest_offset) {
14466                                         ndr->relative_highest_offset = ndr->offset;
14467                                 }
14468                                 ndr->offset = _relative_save_offset;
14469                         }
14470                         ndr->flags = _flags_save_string;
14471                 }
14472                 {
14473                         uint32_t _flags_save_string_array = ndr->flags;
14474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14475                         if (r->dependent_files) {
14476                                 uint32_t _relative_save_offset;
14477                                 _relative_save_offset = ndr->offset;
14478                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14479                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14480                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14481                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14482                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14483                                 if (ndr->offset > ndr->relative_highest_offset) {
14484                                         ndr->relative_highest_offset = ndr->offset;
14485                                 }
14486                                 ndr->offset = _relative_save_offset;
14487                         }
14488                         ndr->flags = _flags_save_string_array;
14489                 }
14490                 {
14491                         uint32_t _flags_save_string = ndr->flags;
14492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14493                         if (r->monitor_name) {
14494                                 uint32_t _relative_save_offset;
14495                                 _relative_save_offset = ndr->offset;
14496                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14497                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14498                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14499                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14500                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14501                                 if (ndr->offset > ndr->relative_highest_offset) {
14502                                         ndr->relative_highest_offset = ndr->offset;
14503                                 }
14504                                 ndr->offset = _relative_save_offset;
14505                         }
14506                         ndr->flags = _flags_save_string;
14507                 }
14508                 {
14509                         uint32_t _flags_save_string = ndr->flags;
14510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14511                         if (r->default_datatype) {
14512                                 uint32_t _relative_save_offset;
14513                                 _relative_save_offset = ndr->offset;
14514                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14515                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14516                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14517                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14518                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14519                                 if (ndr->offset > ndr->relative_highest_offset) {
14520                                         ndr->relative_highest_offset = ndr->offset;
14521                                 }
14522                                 ndr->offset = _relative_save_offset;
14523                         }
14524                         ndr->flags = _flags_save_string;
14525                 }
14526                 {
14527                         uint32_t _flags_save_string_array = ndr->flags;
14528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14529                         if (r->previous_names) {
14530                                 uint32_t _relative_save_offset;
14531                                 _relative_save_offset = ndr->offset;
14532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14533                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14534                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14535                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14537                                 if (ndr->offset > ndr->relative_highest_offset) {
14538                                         ndr->relative_highest_offset = ndr->offset;
14539                                 }
14540                                 ndr->offset = _relative_save_offset;
14541                         }
14542                         ndr->flags = _flags_save_string_array;
14543                 }
14544                 {
14545                         uint32_t _flags_save_string = ndr->flags;
14546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14547                         if (r->manufacturer_name) {
14548                                 uint32_t _relative_save_offset;
14549                                 _relative_save_offset = ndr->offset;
14550                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14551                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14552                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14553                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14554                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14555                                 if (ndr->offset > ndr->relative_highest_offset) {
14556                                         ndr->relative_highest_offset = ndr->offset;
14557                                 }
14558                                 ndr->offset = _relative_save_offset;
14559                         }
14560                         ndr->flags = _flags_save_string;
14561                 }
14562                 {
14563                         uint32_t _flags_save_string = ndr->flags;
14564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14565                         if (r->manufacturer_url) {
14566                                 uint32_t _relative_save_offset;
14567                                 _relative_save_offset = ndr->offset;
14568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14569                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14570                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14571                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14572                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14573                                 if (ndr->offset > ndr->relative_highest_offset) {
14574                                         ndr->relative_highest_offset = ndr->offset;
14575                                 }
14576                                 ndr->offset = _relative_save_offset;
14577                         }
14578                         ndr->flags = _flags_save_string;
14579                 }
14580                 {
14581                         uint32_t _flags_save_string = ndr->flags;
14582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14583                         if (r->hardware_id) {
14584                                 uint32_t _relative_save_offset;
14585                                 _relative_save_offset = ndr->offset;
14586                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14587                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14588                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14589                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14590                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14591                                 if (ndr->offset > ndr->relative_highest_offset) {
14592                                         ndr->relative_highest_offset = ndr->offset;
14593                                 }
14594                                 ndr->offset = _relative_save_offset;
14595                         }
14596                         ndr->flags = _flags_save_string;
14597                 }
14598                 {
14599                         uint32_t _flags_save_string = ndr->flags;
14600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14601                         if (r->provider) {
14602                                 uint32_t _relative_save_offset;
14603                                 _relative_save_offset = ndr->offset;
14604                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14605                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14606                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14607                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14608                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14609                                 if (ndr->offset > ndr->relative_highest_offset) {
14610                                         ndr->relative_highest_offset = ndr->offset;
14611                                 }
14612                                 ndr->offset = _relative_save_offset;
14613                         }
14614                         ndr->flags = _flags_save_string;
14615                 }
14616                 {
14617                         uint32_t _flags_save_string = ndr->flags;
14618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14619                         if (r->print_processor) {
14620                                 uint32_t _relative_save_offset;
14621                                 _relative_save_offset = ndr->offset;
14622                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14623                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14624                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14625                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14626                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14627                                 if (ndr->offset > ndr->relative_highest_offset) {
14628                                         ndr->relative_highest_offset = ndr->offset;
14629                                 }
14630                                 ndr->offset = _relative_save_offset;
14631                         }
14632                         ndr->flags = _flags_save_string;
14633                 }
14634                 {
14635                         uint32_t _flags_save_string = ndr->flags;
14636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14637                         if (r->vendor_setup) {
14638                                 uint32_t _relative_save_offset;
14639                                 _relative_save_offset = ndr->offset;
14640                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14641                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14642                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14643                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14644                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14645                                 if (ndr->offset > ndr->relative_highest_offset) {
14646                                         ndr->relative_highest_offset = ndr->offset;
14647                                 }
14648                                 ndr->offset = _relative_save_offset;
14649                         }
14650                         ndr->flags = _flags_save_string;
14651                 }
14652                 {
14653                         uint32_t _flags_save_string_array = ndr->flags;
14654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14655                         if (r->color_profiles) {
14656                                 uint32_t _relative_save_offset;
14657                                 _relative_save_offset = ndr->offset;
14658                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14659                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14660                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14661                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14662                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14663                                 if (ndr->offset > ndr->relative_highest_offset) {
14664                                         ndr->relative_highest_offset = ndr->offset;
14665                                 }
14666                                 ndr->offset = _relative_save_offset;
14667                         }
14668                         ndr->flags = _flags_save_string_array;
14669                 }
14670                 {
14671                         uint32_t _flags_save_string = ndr->flags;
14672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14673                         if (r->inf_path) {
14674                                 uint32_t _relative_save_offset;
14675                                 _relative_save_offset = ndr->offset;
14676                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14677                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14678                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14679                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14680                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14681                                 if (ndr->offset > ndr->relative_highest_offset) {
14682                                         ndr->relative_highest_offset = ndr->offset;
14683                                 }
14684                                 ndr->offset = _relative_save_offset;
14685                         }
14686                         ndr->flags = _flags_save_string;
14687                 }
14688                 {
14689                         uint32_t _flags_save_string_array = ndr->flags;
14690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14691                         if (r->core_driver_dependencies) {
14692                                 uint32_t _relative_save_offset;
14693                                 _relative_save_offset = ndr->offset;
14694                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14695                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14696                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14697                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14698                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14699                                 if (ndr->offset > ndr->relative_highest_offset) {
14700                                         ndr->relative_highest_offset = ndr->offset;
14701                                 }
14702                                 ndr->offset = _relative_save_offset;
14703                         }
14704                         ndr->flags = _flags_save_string_array;
14705                 }
14706         }
14707         return NDR_ERR_SUCCESS;
14708 }
14709
14710 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14711 {
14712         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14713         ndr->depth++;
14714         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14715         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14716         ndr->depth++;
14717         if (r->driver_name) {
14718                 ndr_print_string(ndr, "driver_name", r->driver_name);
14719         }
14720         ndr->depth--;
14721         ndr_print_ptr(ndr, "architecture", r->architecture);
14722         ndr->depth++;
14723         if (r->architecture) {
14724                 ndr_print_string(ndr, "architecture", r->architecture);
14725         }
14726         ndr->depth--;
14727         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14728         ndr->depth++;
14729         if (r->driver_path) {
14730                 ndr_print_string(ndr, "driver_path", r->driver_path);
14731         }
14732         ndr->depth--;
14733         ndr_print_ptr(ndr, "data_file", r->data_file);
14734         ndr->depth++;
14735         if (r->data_file) {
14736                 ndr_print_string(ndr, "data_file", r->data_file);
14737         }
14738         ndr->depth--;
14739         ndr_print_ptr(ndr, "config_file", r->config_file);
14740         ndr->depth++;
14741         if (r->config_file) {
14742                 ndr_print_string(ndr, "config_file", r->config_file);
14743         }
14744         ndr->depth--;
14745         ndr_print_ptr(ndr, "help_file", r->help_file);
14746         ndr->depth++;
14747         if (r->help_file) {
14748                 ndr_print_string(ndr, "help_file", r->help_file);
14749         }
14750         ndr->depth--;
14751         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14752         ndr->depth++;
14753         if (r->dependent_files) {
14754                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14755         }
14756         ndr->depth--;
14757         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14758         ndr->depth++;
14759         if (r->monitor_name) {
14760                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14761         }
14762         ndr->depth--;
14763         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14764         ndr->depth++;
14765         if (r->default_datatype) {
14766                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14767         }
14768         ndr->depth--;
14769         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14770         ndr->depth++;
14771         if (r->previous_names) {
14772                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14773         }
14774         ndr->depth--;
14775         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14776         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14777         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14778         ndr->depth++;
14779         if (r->manufacturer_name) {
14780                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14781         }
14782         ndr->depth--;
14783         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14784         ndr->depth++;
14785         if (r->manufacturer_url) {
14786                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14787         }
14788         ndr->depth--;
14789         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14790         ndr->depth++;
14791         if (r->hardware_id) {
14792                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14793         }
14794         ndr->depth--;
14795         ndr_print_ptr(ndr, "provider", r->provider);
14796         ndr->depth++;
14797         if (r->provider) {
14798                 ndr_print_string(ndr, "provider", r->provider);
14799         }
14800         ndr->depth--;
14801         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14802         ndr->depth++;
14803         if (r->print_processor) {
14804                 ndr_print_string(ndr, "print_processor", r->print_processor);
14805         }
14806         ndr->depth--;
14807         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14808         ndr->depth++;
14809         if (r->vendor_setup) {
14810                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14811         }
14812         ndr->depth--;
14813         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14814         ndr->depth++;
14815         if (r->color_profiles) {
14816                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14817         }
14818         ndr->depth--;
14819         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14820         ndr->depth++;
14821         if (r->inf_path) {
14822                 ndr_print_string(ndr, "inf_path", r->inf_path);
14823         }
14824         ndr->depth--;
14825         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14826         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14827         ndr->depth++;
14828         if (r->core_driver_dependencies) {
14829                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14830         }
14831         ndr->depth--;
14832         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14833         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14834         ndr->depth--;
14835 }
14836
14837 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14838 {
14839         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14840 }
14841
14842 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14843 {
14844         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14845         return NDR_ERR_SUCCESS;
14846 }
14847
14848 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14849 {
14850         uint32_t v;
14851         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14852         *r = v;
14853         return NDR_ERR_SUCCESS;
14854 }
14855
14856 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14857 {
14858         const char *val = NULL;
14859
14860         switch (r) {
14861                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14862                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14863                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14864                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14865                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14866         }
14867         ndr_print_enum(ndr, name, "ENUM", val, r);
14868 }
14869
14870 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14871 {
14872         if (ndr_flags & NDR_SCALARS) {
14873                 NDR_CHECK(ndr_push_align(ndr, 5));
14874                 {
14875                         uint32_t _flags_save_string = ndr->flags;
14876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14877                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14878                         ndr->flags = _flags_save_string;
14879                 }
14880                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14882                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14883         }
14884         if (ndr_flags & NDR_BUFFERS) {
14885                 {
14886                         uint32_t _flags_save_string = ndr->flags;
14887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14888                         if (r->file_name) {
14889                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_name));
14890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14891                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_name));
14892                         }
14893                         ndr->flags = _flags_save_string;
14894                 }
14895         }
14896         return NDR_ERR_SUCCESS;
14897 }
14898
14899 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14900 {
14901         uint32_t _ptr_file_name;
14902         TALLOC_CTX *_mem_save_file_name_0;
14903         if (ndr_flags & NDR_SCALARS) {
14904                 NDR_CHECK(ndr_pull_align(ndr, 5));
14905                 {
14906                         uint32_t _flags_save_string = ndr->flags;
14907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14908                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14909                         if (_ptr_file_name) {
14910                                 NDR_PULL_ALLOC(ndr, r->file_name);
14911                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14912                         } else {
14913                                 r->file_name = NULL;
14914                         }
14915                         ndr->flags = _flags_save_string;
14916                 }
14917                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14919                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14920         }
14921         if (ndr_flags & NDR_BUFFERS) {
14922                 {
14923                         uint32_t _flags_save_string = ndr->flags;
14924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14925                         if (r->file_name) {
14926                                 uint32_t _relative_save_offset;
14927                                 _relative_save_offset = ndr->offset;
14928                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14929                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14930                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14931                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14932                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14933                                 if (ndr->offset > ndr->relative_highest_offset) {
14934                                         ndr->relative_highest_offset = ndr->offset;
14935                                 }
14936                                 ndr->offset = _relative_save_offset;
14937                         }
14938                         ndr->flags = _flags_save_string;
14939                 }
14940         }
14941         return NDR_ERR_SUCCESS;
14942 }
14943
14944 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14945 {
14946         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14947         ndr->depth++;
14948         ndr_print_ptr(ndr, "file_name", r->file_name);
14949         ndr->depth++;
14950         if (r->file_name) {
14951                 ndr_print_string(ndr, "file_name", r->file_name);
14952         }
14953         ndr->depth--;
14954         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14955         ndr_print_uint32(ndr, "file_version", r->file_version);
14956         ndr->depth--;
14957 }
14958
14959 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14960 {
14961         uint32_t cntr_file_info_1;
14962         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14963         ndr->depth++;
14964         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14965         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14966         ndr->depth++;
14967         if (r->driver_name) {
14968                 ndr_print_string(ndr, "driver_name", r->driver_name);
14969         }
14970         ndr->depth--;
14971         ndr_print_ptr(ndr, "architecture", r->architecture);
14972         ndr->depth++;
14973         if (r->architecture) {
14974                 ndr_print_string(ndr, "architecture", r->architecture);
14975         }
14976         ndr->depth--;
14977         ndr_print_ptr(ndr, "file_info", r->file_info);
14978         ndr->depth++;
14979         if (r->file_info) {
14980                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14981                 ndr->depth++;
14982                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14983                         char *idx_1=NULL;
14984                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14985                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14986                                 free(idx_1);
14987                         }
14988                 }
14989                 ndr->depth--;
14990         }
14991         ndr->depth--;
14992         ndr_print_uint32(ndr, "file_count", r->file_count);
14993         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14994         ndr->depth++;
14995         if (r->monitor_name) {
14996                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14997         }
14998         ndr->depth--;
14999         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
15000         ndr->depth++;
15001         if (r->default_datatype) {
15002                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
15003         }
15004         ndr->depth--;
15005         ndr_print_ptr(ndr, "previous_names", r->previous_names);
15006         ndr->depth++;
15007         if (r->previous_names) {
15008                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
15009         }
15010         ndr->depth--;
15011         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
15012         ndr_print_hyper(ndr, "driver_version", r->driver_version);
15013         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
15014         ndr->depth++;
15015         if (r->manufacturer_name) {
15016                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
15017         }
15018         ndr->depth--;
15019         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
15020         ndr->depth++;
15021         if (r->manufacturer_url) {
15022                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
15023         }
15024         ndr->depth--;
15025         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
15026         ndr->depth++;
15027         if (r->hardware_id) {
15028                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
15029         }
15030         ndr->depth--;
15031         ndr_print_ptr(ndr, "provider", r->provider);
15032         ndr->depth++;
15033         if (r->provider) {
15034                 ndr_print_string(ndr, "provider", r->provider);
15035         }
15036         ndr->depth--;
15037         ndr->depth--;
15038 }
15039
15040 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
15041 {
15042         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
15043 }
15044
15045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
15046 {
15047         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15048         {
15049                 uint32_t _flags_save_UNION = ndr->flags;
15050                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15051                 if (ndr_flags & NDR_SCALARS) {
15052                         int level = ndr_push_get_switch_value(ndr, r);
15053                         NDR_CHECK(ndr_push_union_align(ndr, 8));
15054                         switch (level) {
15055                                 case 1: {
15056                                         NDR_CHECK(ndr_push_align(ndr, 5));
15057                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15058                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
15059                                 break; }
15060
15061                                 case 2: {
15062                                         NDR_CHECK(ndr_push_align(ndr, 5));
15063                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15064                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
15065                                 break; }
15066
15067                                 case 3: {
15068                                         NDR_CHECK(ndr_push_align(ndr, 5));
15069                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15070                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
15071                                 break; }
15072
15073                                 case 4: {
15074                                         NDR_CHECK(ndr_push_align(ndr, 5));
15075                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15076                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
15077                                 break; }
15078
15079                                 case 5: {
15080                                         NDR_CHECK(ndr_push_align(ndr, 5));
15081                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15082                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
15083                                 break; }
15084
15085                                 case 6: {
15086                                         NDR_CHECK(ndr_push_align(ndr, 8));
15087                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15088                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
15089                                 break; }
15090
15091                                 case 7: {
15092                                         NDR_CHECK(ndr_push_align(ndr, 5));
15093                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15094                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
15095                                 break; }
15096
15097                                 case 8: {
15098                                         NDR_CHECK(ndr_push_align(ndr, 8));
15099                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15100                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
15101                                 break; }
15102
15103                                 case 101: {
15104                                         NDR_CHECK(ndr_push_align(ndr, 8));
15105                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15106                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
15107                                 break; }
15108
15109                                 default: {
15110                                 break; }
15111
15112                         }
15113                 }
15114                 if (ndr_flags & NDR_BUFFERS) {
15115                         int level = ndr_push_get_switch_value(ndr, r);
15116                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15117                         switch (level) {
15118                                 case 1:
15119                                         NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
15120                                 break;
15121
15122                                 case 2:
15123                                         NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
15124                                 break;
15125
15126                                 case 3:
15127                                         NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
15128                                 break;
15129
15130                                 case 4:
15131                                         NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
15132                                 break;
15133
15134                                 case 5:
15135                                         NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
15136                                 break;
15137
15138                                 case 6:
15139                                         NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
15140                                 break;
15141
15142                                 case 7:
15143                                         NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
15144                                 break;
15145
15146                                 case 8:
15147                                         NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
15148                                 break;
15149
15150                                 case 101:
15151                                         NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
15152                                 break;
15153
15154                                 default:
15155                                 break;
15156
15157                         }
15158                 }
15159                 ndr->flags = _flags_save_UNION;
15160         }
15161         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15162         return NDR_ERR_SUCCESS;
15163 }
15164
15165 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
15166 {
15167         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15168         int level;
15169         {
15170                 uint32_t _flags_save_UNION = ndr->flags;
15171                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15172                 level = ndr_pull_get_switch_value(ndr, r);
15173                 if (ndr_flags & NDR_SCALARS) {
15174                         NDR_CHECK(ndr_pull_union_align(ndr, 8));
15175                         switch (level) {
15176                                 case 1: {
15177                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15178                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15179                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
15180                                 break; }
15181
15182                                 case 2: {
15183                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15184                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15185                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
15186                                 break; }
15187
15188                                 case 3: {
15189                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15190                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15191                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
15192                                 break; }
15193
15194                                 case 4: {
15195                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15196                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15197                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
15198                                 break; }
15199
15200                                 case 5: {
15201                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15202                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15203                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
15204                                 break; }
15205
15206                                 case 6: {
15207                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15208                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15209                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
15210                                 break; }
15211
15212                                 case 7: {
15213                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15214                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15215                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
15216                                 break; }
15217
15218                                 case 8: {
15219                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15220                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15221                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
15222                                 break; }
15223
15224                                 case 101: {
15225                                         NDR_CHECK(ndr_pull_align(ndr, 8));
15226                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15227                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
15228                                 break; }
15229
15230                                 default: {
15231                                 break; }
15232
15233                         }
15234                 }
15235                 if (ndr_flags & NDR_BUFFERS) {
15236                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15237                         switch (level) {
15238                                 case 1:
15239                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
15240                                 break;
15241
15242                                 case 2:
15243                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
15244                                 break;
15245
15246                                 case 3:
15247                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
15248                                 break;
15249
15250                                 case 4:
15251                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
15252                                 break;
15253
15254                                 case 5:
15255                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
15256                                 break;
15257
15258                                 case 6:
15259                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
15260                                 break;
15261
15262                                 case 7:
15263                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
15264                                 break;
15265
15266                                 case 8:
15267                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
15268                                 break;
15269
15270                                 case 101:
15271                                         NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
15272                                 break;
15273
15274                                 default:
15275                                 break;
15276
15277                         }
15278                 }
15279                 ndr->flags = _flags_save_UNION;
15280         }
15281         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15282         return NDR_ERR_SUCCESS;
15283 }
15284
15285 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
15286 {
15287         int level;
15288         {
15289                 uint32_t _flags_save_UNION = ndr->flags;
15290                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15291                 level = ndr_print_get_switch_value(ndr, r);
15292                 ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
15293                 switch (level) {
15294                         case 1:
15295                                 ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
15296                         break;
15297
15298                         case 2:
15299                                 ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
15300                         break;
15301
15302                         case 3:
15303                                 ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
15304                         break;
15305
15306                         case 4:
15307                                 ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
15308                         break;
15309
15310                         case 5:
15311                                 ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
15312                         break;
15313
15314                         case 6:
15315                                 ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
15316                         break;
15317
15318                         case 7:
15319                                 ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
15320                         break;
15321
15322                         case 8:
15323                                 ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
15324                         break;
15325
15326                         case 101:
15327                                 ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
15328                         break;
15329
15330                         default:
15331                         break;
15332
15333                 }
15334                 ndr->flags = _flags_save_UNION;
15335         }
15336 }
15337
15338 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15339 {
15340         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15341         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
15342 }
15343
15344 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
15345 {
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_push_align(ndr, 4));
15348                 {
15349                         uint32_t _flags_save_string = ndr->flags;
15350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15351                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15352                         ndr->flags = _flags_save_string;
15353                 }
15354                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15355         }
15356         if (ndr_flags & NDR_BUFFERS) {
15357         }
15358         return NDR_ERR_SUCCESS;
15359 }
15360
15361 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
15362 {
15363         if (ndr_flags & NDR_SCALARS) {
15364                 NDR_CHECK(ndr_pull_align(ndr, 4));
15365                 {
15366                         uint32_t _flags_save_string = ndr->flags;
15367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15368                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15369                         ndr->flags = _flags_save_string;
15370                 }
15371                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15372         }
15373         if (ndr_flags & NDR_BUFFERS) {
15374         }
15375         return NDR_ERR_SUCCESS;
15376 }
15377
15378 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
15379 {
15380         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
15381         ndr->depth++;
15382         ndr_print_string(ndr, "directory_name", r->directory_name);
15383         ndr->depth--;
15384 }
15385
15386 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15387 {
15388         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
15389 }
15390
15391 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
15392 {
15393         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15394         {
15395                 uint32_t _flags_save_UNION = ndr->flags;
15396                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15397                 if (ndr_flags & NDR_SCALARS) {
15398                         int level = ndr_push_get_switch_value(ndr, r);
15399                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15400                         switch (level) {
15401                                 case 1: {
15402                                         NDR_CHECK(ndr_push_align(ndr, 4));
15403                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15404                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15405                                 break; }
15406
15407                                 default: {
15408                                         NDR_CHECK(ndr_push_align(ndr, 4));
15409                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15410                                         NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15411                                 break; }
15412
15413                         }
15414                 }
15415                 if (ndr_flags & NDR_BUFFERS) {
15416                         int level = ndr_push_get_switch_value(ndr, r);
15417                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15418                         switch (level) {
15419                                 case 1:
15420                                 break;
15421
15422                                 default:
15423                                 break;
15424
15425                         }
15426                 }
15427                 ndr->flags = _flags_save_UNION;
15428         }
15429         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15430         return NDR_ERR_SUCCESS;
15431 }
15432
15433 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
15434 {
15435         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15436         int level;
15437         {
15438                 uint32_t _flags_save_UNION = ndr->flags;
15439                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15440                 level = ndr_pull_get_switch_value(ndr, r);
15441                 if (ndr_flags & NDR_SCALARS) {
15442                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15443                         switch (level) {
15444                                 case 1: {
15445                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15446                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15447                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15448                                 break; }
15449
15450                                 default: {
15451                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15452                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15453                                         NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15454                                 break; }
15455
15456                         }
15457                 }
15458                 if (ndr_flags & NDR_BUFFERS) {
15459                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15460                         switch (level) {
15461                                 case 1:
15462                                 break;
15463
15464                                 default:
15465                                 break;
15466
15467                         }
15468                 }
15469                 ndr->flags = _flags_save_UNION;
15470         }
15471         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15472         return NDR_ERR_SUCCESS;
15473 }
15474
15475 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15476 {
15477         int level;
15478         {
15479                 uint32_t _flags_save_UNION = ndr->flags;
15480                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15481                 level = ndr_print_get_switch_value(ndr, r);
15482                 ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15483                 switch (level) {
15484                         case 1:
15485                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15486                         break;
15487
15488                         default:
15489                                 ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15490                         break;
15491
15492                 }
15493                 ndr->flags = _flags_save_UNION;
15494         }
15495 }
15496
15497 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15498 {
15499         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15500         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15501 }
15502
15503 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15504 {
15505         if (ndr_flags & NDR_SCALARS) {
15506                 NDR_CHECK(ndr_push_align(ndr, 5));
15507                 {
15508                         uint32_t _flags_save_string = ndr->flags;
15509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15511                         ndr->flags = _flags_save_string;
15512                 }
15513                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15514         }
15515         if (ndr_flags & NDR_BUFFERS) {
15516                 {
15517                         uint32_t _flags_save_string = ndr->flags;
15518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15519                         if (r->print_processor_name) {
15520                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->print_processor_name));
15521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15522                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->print_processor_name));
15523                         }
15524                         ndr->flags = _flags_save_string;
15525                 }
15526         }
15527         return NDR_ERR_SUCCESS;
15528 }
15529
15530 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15531 {
15532         uint32_t _ptr_print_processor_name;
15533         TALLOC_CTX *_mem_save_print_processor_name_0;
15534         if (ndr_flags & NDR_SCALARS) {
15535                 NDR_CHECK(ndr_pull_align(ndr, 5));
15536                 {
15537                         uint32_t _flags_save_string = ndr->flags;
15538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15539                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15540                         if (_ptr_print_processor_name) {
15541                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15542                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15543                         } else {
15544                                 r->print_processor_name = NULL;
15545                         }
15546                         ndr->flags = _flags_save_string;
15547                 }
15548                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15549         }
15550         if (ndr_flags & NDR_BUFFERS) {
15551                 {
15552                         uint32_t _flags_save_string = ndr->flags;
15553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15554                         if (r->print_processor_name) {
15555                                 uint32_t _relative_save_offset;
15556                                 _relative_save_offset = ndr->offset;
15557                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15558                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15559                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15560                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15561                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15562                                 if (ndr->offset > ndr->relative_highest_offset) {
15563                                         ndr->relative_highest_offset = ndr->offset;
15564                                 }
15565                                 ndr->offset = _relative_save_offset;
15566                         }
15567                         ndr->flags = _flags_save_string;
15568                 }
15569         }
15570         return NDR_ERR_SUCCESS;
15571 }
15572
15573 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15574 {
15575         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15576         ndr->depth++;
15577         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15578         ndr->depth++;
15579         if (r->print_processor_name) {
15580                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15581         }
15582         ndr->depth--;
15583         ndr->depth--;
15584 }
15585
15586 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15587 {
15588         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15589 }
15590
15591 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15592 {
15593         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15594         {
15595                 uint32_t _flags_save_UNION = ndr->flags;
15596                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15597                 if (ndr_flags & NDR_SCALARS) {
15598                         int level = ndr_push_get_switch_value(ndr, r);
15599                         NDR_CHECK(ndr_push_union_align(ndr, 5));
15600                         switch (level) {
15601                                 case 1: {
15602                                         NDR_CHECK(ndr_push_align(ndr, 5));
15603                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15604                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15605                                 break; }
15606
15607                                 default: {
15608                                 break; }
15609
15610                         }
15611                 }
15612                 if (ndr_flags & NDR_BUFFERS) {
15613                         int level = ndr_push_get_switch_value(ndr, r);
15614                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15615                         switch (level) {
15616                                 case 1:
15617                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15618                                 break;
15619
15620                                 default:
15621                                 break;
15622
15623                         }
15624                 }
15625                 ndr->flags = _flags_save_UNION;
15626         }
15627         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15628         return NDR_ERR_SUCCESS;
15629 }
15630
15631 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15632 {
15633         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15634         int level;
15635         {
15636                 uint32_t _flags_save_UNION = ndr->flags;
15637                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15638                 level = ndr_pull_get_switch_value(ndr, r);
15639                 if (ndr_flags & NDR_SCALARS) {
15640                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
15641                         switch (level) {
15642                                 case 1: {
15643                                         NDR_CHECK(ndr_pull_align(ndr, 5));
15644                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15645                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15646                                 break; }
15647
15648                                 default: {
15649                                 break; }
15650
15651                         }
15652                 }
15653                 if (ndr_flags & NDR_BUFFERS) {
15654                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15655                         switch (level) {
15656                                 case 1:
15657                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15658                                 break;
15659
15660                                 default:
15661                                 break;
15662
15663                         }
15664                 }
15665                 ndr->flags = _flags_save_UNION;
15666         }
15667         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15668         return NDR_ERR_SUCCESS;
15669 }
15670
15671 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15672 {
15673         int level;
15674         {
15675                 uint32_t _flags_save_UNION = ndr->flags;
15676                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15677                 level = ndr_print_get_switch_value(ndr, r);
15678                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15679                 switch (level) {
15680                         case 1:
15681                                 ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15682                         break;
15683
15684                         default:
15685                         break;
15686
15687                 }
15688                 ndr->flags = _flags_save_UNION;
15689         }
15690 }
15691
15692 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15693 {
15694         if (ndr_flags & NDR_SCALARS) {
15695                 NDR_CHECK(ndr_push_align(ndr, 4));
15696                 {
15697                         uint32_t _flags_save_string = ndr->flags;
15698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15699                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15700                         ndr->flags = _flags_save_string;
15701                 }
15702                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15703         }
15704         if (ndr_flags & NDR_BUFFERS) {
15705         }
15706         return NDR_ERR_SUCCESS;
15707 }
15708
15709 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15710 {
15711         if (ndr_flags & NDR_SCALARS) {
15712                 NDR_CHECK(ndr_pull_align(ndr, 4));
15713                 {
15714                         uint32_t _flags_save_string = ndr->flags;
15715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15716                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15717                         ndr->flags = _flags_save_string;
15718                 }
15719                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15720         }
15721         if (ndr_flags & NDR_BUFFERS) {
15722         }
15723         return NDR_ERR_SUCCESS;
15724 }
15725
15726 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15727 {
15728         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15729         ndr->depth++;
15730         ndr_print_string(ndr, "directory_name", r->directory_name);
15731         ndr->depth--;
15732 }
15733
15734 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15735 {
15736         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15737 }
15738
15739 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15740 {
15741         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15742         {
15743                 uint32_t _flags_save_UNION = ndr->flags;
15744                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15745                 if (ndr_flags & NDR_SCALARS) {
15746                         int level = ndr_push_get_switch_value(ndr, r);
15747                         NDR_CHECK(ndr_push_union_align(ndr, 4));
15748                         switch (level) {
15749                                 case 1: {
15750                                         NDR_CHECK(ndr_push_align(ndr, 4));
15751                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15752                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15753                                 break; }
15754
15755                                 default: {
15756                                         NDR_CHECK(ndr_push_align(ndr, 4));
15757                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15758                                         NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15759                                 break; }
15760
15761                         }
15762                 }
15763                 if (ndr_flags & NDR_BUFFERS) {
15764                         int level = ndr_push_get_switch_value(ndr, r);
15765                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15766                         switch (level) {
15767                                 case 1:
15768                                 break;
15769
15770                                 default:
15771                                 break;
15772
15773                         }
15774                 }
15775                 ndr->flags = _flags_save_UNION;
15776         }
15777         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15778         return NDR_ERR_SUCCESS;
15779 }
15780
15781 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15782 {
15783         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15784         int level;
15785         {
15786                 uint32_t _flags_save_UNION = ndr->flags;
15787                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15788                 level = ndr_pull_get_switch_value(ndr, r);
15789                 if (ndr_flags & NDR_SCALARS) {
15790                         NDR_CHECK(ndr_pull_union_align(ndr, 4));
15791                         switch (level) {
15792                                 case 1: {
15793                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15794                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15795                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15796                                 break; }
15797
15798                                 default: {
15799                                         NDR_CHECK(ndr_pull_align(ndr, 4));
15800                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15801                                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15802                                 break; }
15803
15804                         }
15805                 }
15806                 if (ndr_flags & NDR_BUFFERS) {
15807                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15808                         switch (level) {
15809                                 case 1:
15810                                 break;
15811
15812                                 default:
15813                                 break;
15814
15815                         }
15816                 }
15817                 ndr->flags = _flags_save_UNION;
15818         }
15819         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15820         return NDR_ERR_SUCCESS;
15821 }
15822
15823 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15824 {
15825         int level;
15826         {
15827                 uint32_t _flags_save_UNION = ndr->flags;
15828                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
15829                 level = ndr_print_get_switch_value(ndr, r);
15830                 ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15831                 switch (level) {
15832                         case 1:
15833                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15834                         break;
15835
15836                         default:
15837                                 ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15838                         break;
15839
15840                 }
15841                 ndr->flags = _flags_save_UNION;
15842         }
15843 }
15844
15845 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15846 {
15847         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
15848         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15849 }
15850
15851 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15852 {
15853         if (ndr_flags & NDR_SCALARS) {
15854                 NDR_CHECK(ndr_push_align(ndr, 5));
15855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15858                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15859         }
15860         if (ndr_flags & NDR_BUFFERS) {
15861                 if (r->document_name) {
15862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15866                 }
15867                 if (r->output_file) {
15868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15872                 }
15873                 if (r->datatype) {
15874                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15877                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15878                 }
15879         }
15880         return NDR_ERR_SUCCESS;
15881 }
15882
15883 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15884 {
15885         uint32_t _ptr_document_name;
15886         TALLOC_CTX *_mem_save_document_name_0;
15887         uint32_t _ptr_output_file;
15888         TALLOC_CTX *_mem_save_output_file_0;
15889         uint32_t _ptr_datatype;
15890         TALLOC_CTX *_mem_save_datatype_0;
15891         if (ndr_flags & NDR_SCALARS) {
15892                 NDR_CHECK(ndr_pull_align(ndr, 5));
15893                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15894                 if (_ptr_document_name) {
15895                         NDR_PULL_ALLOC(ndr, r->document_name);
15896                 } else {
15897                         r->document_name = NULL;
15898                 }
15899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15900                 if (_ptr_output_file) {
15901                         NDR_PULL_ALLOC(ndr, r->output_file);
15902                 } else {
15903                         r->output_file = NULL;
15904                 }
15905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15906                 if (_ptr_datatype) {
15907                         NDR_PULL_ALLOC(ndr, r->datatype);
15908                 } else {
15909                         r->datatype = NULL;
15910                 }
15911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15912         }
15913         if (ndr_flags & NDR_BUFFERS) {
15914                 if (r->document_name) {
15915                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15916                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15919                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15920                                 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));
15921                         }
15922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15925                 }
15926                 if (r->output_file) {
15927                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15928                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15931                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15932                                 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));
15933                         }
15934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15937                 }
15938                 if (r->datatype) {
15939                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15940                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15942                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15943                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15944                                 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));
15945                         }
15946                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15947                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15949                 }
15950         }
15951         return NDR_ERR_SUCCESS;
15952 }
15953
15954 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15955 {
15956         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15957         ndr->depth++;
15958         ndr_print_ptr(ndr, "document_name", r->document_name);
15959         ndr->depth++;
15960         if (r->document_name) {
15961                 ndr_print_string(ndr, "document_name", r->document_name);
15962         }
15963         ndr->depth--;
15964         ndr_print_ptr(ndr, "output_file", r->output_file);
15965         ndr->depth++;
15966         if (r->output_file) {
15967                 ndr_print_string(ndr, "output_file", r->output_file);
15968         }
15969         ndr->depth--;
15970         ndr_print_ptr(ndr, "datatype", r->datatype);
15971         ndr->depth++;
15972         if (r->datatype) {
15973                 ndr_print_string(ndr, "datatype", r->datatype);
15974         }
15975         ndr->depth--;
15976         ndr->depth--;
15977 }
15978
15979 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15980 {
15981         if (ndr_flags & NDR_SCALARS) {
15982                 int level = ndr_push_get_switch_value(ndr, r);
15983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15984                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15985                 switch (level) {
15986                         case 1: {
15987                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15988                         break; }
15989
15990                         case 2: {
15991                         break; }
15992
15993                         case 3: {
15994                         break; }
15995
15996                         default: {
15997                         break; }
15998
15999                 }
16000         }
16001         if (ndr_flags & NDR_BUFFERS) {
16002                 int level = ndr_push_get_switch_value(ndr, r);
16003                 switch (level) {
16004                         case 1:
16005                                 if (r->info1) {
16006                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16007                                 }
16008                         break;
16009
16010                         case 2:
16011                         break;
16012
16013                         case 3:
16014                         break;
16015
16016                         default:
16017                         break;
16018
16019                 }
16020         }
16021         return NDR_ERR_SUCCESS;
16022 }
16023
16024 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
16025 {
16026         int level;
16027         uint32_t _level;
16028         TALLOC_CTX *_mem_save_info1_0;
16029         level = ndr_pull_get_switch_value(ndr, r);
16030         if (ndr_flags & NDR_SCALARS) {
16031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16032                 if (_level != level) {
16033                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16034                 }
16035                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16036                 switch (level) {
16037                         case 1: {
16038                                 uint32_t _ptr_info1;
16039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16040                                 if (_ptr_info1) {
16041                                         NDR_PULL_ALLOC(ndr, r->info1);
16042                                 } else {
16043                                         r->info1 = NULL;
16044                                 }
16045                         break; }
16046
16047                         case 2: {
16048                         break; }
16049
16050                         case 3: {
16051                         break; }
16052
16053                         default: {
16054                         break; }
16055
16056                 }
16057         }
16058         if (ndr_flags & NDR_BUFFERS) {
16059                 switch (level) {
16060                         case 1:
16061                                 if (r->info1) {
16062                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16063                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16064                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16065                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16066                                 }
16067                         break;
16068
16069                         case 2:
16070                         break;
16071
16072                         case 3:
16073                         break;
16074
16075                         default:
16076                         break;
16077
16078                 }
16079         }
16080         return NDR_ERR_SUCCESS;
16081 }
16082
16083 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
16084 {
16085         int level;
16086         level = ndr_print_get_switch_value(ndr, r);
16087         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
16088         switch (level) {
16089                 case 1:
16090                         ndr_print_ptr(ndr, "info1", r->info1);
16091                         ndr->depth++;
16092                         if (r->info1) {
16093                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
16094                         }
16095                         ndr->depth--;
16096                 break;
16097
16098                 case 2:
16099                 break;
16100
16101                 case 3:
16102                 break;
16103
16104                 default:
16105                 break;
16106
16107         }
16108 }
16109
16110 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
16111 {
16112         if (ndr_flags & NDR_SCALARS) {
16113                 NDR_CHECK(ndr_push_align(ndr, 4));
16114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
16115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
16116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
16117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
16118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
16119                 {
16120                         uint32_t _flags_save_string = ndr->flags;
16121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16122                         {
16123                                 struct ndr_push *_ndr_extra_string;
16124                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16125                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
16126                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16127                         }
16128                         ndr->flags = _flags_save_string;
16129                 }
16130                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16131         }
16132         if (ndr_flags & NDR_BUFFERS) {
16133         }
16134         return NDR_ERR_SUCCESS;
16135 }
16136
16137 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
16138 {
16139         if (ndr_flags & NDR_SCALARS) {
16140                 NDR_CHECK(ndr_pull_align(ndr, 4));
16141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
16142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
16143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
16144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
16145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
16146                 {
16147                         uint32_t _flags_save_string = ndr->flags;
16148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16149                         {
16150                                 struct ndr_pull *_ndr_extra_string;
16151                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16152                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
16153                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16154                         }
16155                         ndr->flags = _flags_save_string;
16156                 }
16157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16158         }
16159         if (ndr_flags & NDR_BUFFERS) {
16160         }
16161         return NDR_ERR_SUCCESS;
16162 }
16163
16164 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
16165 {
16166         ndr_print_struct(ndr, name, "spoolss_OSVersion");
16167         ndr->depth++;
16168         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);
16169         ndr_print_uint32(ndr, "major", r->major);
16170         ndr_print_uint32(ndr, "minor", r->minor);
16171         ndr_print_uint32(ndr, "build", r->build);
16172         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
16173         ndr_print_string(ndr, "extra_string", r->extra_string);
16174         ndr->depth--;
16175 }
16176
16177 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
16178 {
16179         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
16180 }
16181
16182 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
16183 {
16184         if (ndr_flags & NDR_SCALARS) {
16185                 NDR_CHECK(ndr_push_align(ndr, 4));
16186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
16187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
16188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
16189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
16190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
16191                 {
16192                         uint32_t _flags_save_string = ndr->flags;
16193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16194                         {
16195                                 struct ndr_push *_ndr_extra_string;
16196                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16197                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
16198                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16199                         }
16200                         ndr->flags = _flags_save_string;
16201                 }
16202                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
16203                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
16204                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
16205                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
16206                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
16207                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16208         }
16209         if (ndr_flags & NDR_BUFFERS) {
16210         }
16211         return NDR_ERR_SUCCESS;
16212 }
16213
16214 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
16215 {
16216         if (ndr_flags & NDR_SCALARS) {
16217                 NDR_CHECK(ndr_pull_align(ndr, 4));
16218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
16219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
16220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
16221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
16222                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
16223                 {
16224                         uint32_t _flags_save_string = ndr->flags;
16225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16226                         {
16227                                 struct ndr_pull *_ndr_extra_string;
16228                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
16229                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
16230                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
16231                         }
16232                         ndr->flags = _flags_save_string;
16233                 }
16234                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
16235                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
16236                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
16237                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
16238                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
16239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16240         }
16241         if (ndr_flags & NDR_BUFFERS) {
16242         }
16243         return NDR_ERR_SUCCESS;
16244 }
16245
16246 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
16247 {
16248         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
16249         ndr->depth++;
16250         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);
16251         ndr_print_uint32(ndr, "major", r->major);
16252         ndr_print_uint32(ndr, "minor", r->minor);
16253         ndr_print_uint32(ndr, "build", r->build);
16254         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
16255         ndr_print_string(ndr, "extra_string", r->extra_string);
16256         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
16257         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
16258         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
16259         ndr_print_uint8(ndr, "product_type", r->product_type);
16260         ndr_print_uint8(ndr, "reserved", r->reserved);
16261         ndr->depth--;
16262 }
16263
16264 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
16265 {
16266         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
16267 }
16268
16269 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
16270 {
16271         if (ndr_flags & NDR_SCALARS) {
16272                 int level = ndr_push_get_switch_value(ndr, r);
16273                 NDR_CHECK(ndr_push_union_align(ndr, 4));
16274                 switch (level) {
16275                         case REG_NONE: {
16276                         break; }
16277
16278                         case REG_SZ: {
16279                                 {
16280                                         uint32_t _flags_save_string = ndr->flags;
16281                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16282                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
16283                                         ndr->flags = _flags_save_string;
16284                                 }
16285                         break; }
16286
16287                         case REG_BINARY: {
16288                                 {
16289                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16290                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16291                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
16292                                         ndr->flags = _flags_save_DATA_BLOB;
16293                                 }
16294                         break; }
16295
16296                         case REG_DWORD: {
16297                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
16298                         break; }
16299
16300                         case REG_MULTI_SZ: {
16301                                 {
16302                                         uint32_t _flags_save_string_array = ndr->flags;
16303                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16304                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
16305                                         ndr->flags = _flags_save_string_array;
16306                                 }
16307                         break; }
16308
16309                         default: {
16310                                 {
16311                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16312                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16313                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
16314                                         ndr->flags = _flags_save_DATA_BLOB;
16315                                 }
16316                         break; }
16317
16318                 }
16319         }
16320         if (ndr_flags & NDR_BUFFERS) {
16321                 int level = ndr_push_get_switch_value(ndr, r);
16322                 switch (level) {
16323                         case REG_NONE:
16324                         break;
16325
16326                         case REG_SZ:
16327                         break;
16328
16329                         case REG_BINARY:
16330                         break;
16331
16332                         case REG_DWORD:
16333                         break;
16334
16335                         case REG_MULTI_SZ:
16336                         break;
16337
16338                         default:
16339                         break;
16340
16341                 }
16342         }
16343         return NDR_ERR_SUCCESS;
16344 }
16345
16346 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
16347 {
16348         int level;
16349         level = ndr_pull_get_switch_value(ndr, r);
16350         if (ndr_flags & NDR_SCALARS) {
16351                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
16352                 switch (level) {
16353                         case REG_NONE: {
16354                         break; }
16355
16356                         case REG_SZ: {
16357                                 {
16358                                         uint32_t _flags_save_string = ndr->flags;
16359                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16360                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
16361                                         ndr->flags = _flags_save_string;
16362                                 }
16363                         break; }
16364
16365                         case REG_BINARY: {
16366                                 {
16367                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16368                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16369                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
16370                                         ndr->flags = _flags_save_DATA_BLOB;
16371                                 }
16372                         break; }
16373
16374                         case REG_DWORD: {
16375                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
16376                         break; }
16377
16378                         case REG_MULTI_SZ: {
16379                                 {
16380                                         uint32_t _flags_save_string_array = ndr->flags;
16381                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16382                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
16383                                         ndr->flags = _flags_save_string_array;
16384                                 }
16385                         break; }
16386
16387                         default: {
16388                                 {
16389                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
16390                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
16391                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
16392                                         ndr->flags = _flags_save_DATA_BLOB;
16393                                 }
16394                         break; }
16395
16396                 }
16397         }
16398         if (ndr_flags & NDR_BUFFERS) {
16399                 switch (level) {
16400                         case REG_NONE:
16401                         break;
16402
16403                         case REG_SZ:
16404                         break;
16405
16406                         case REG_BINARY:
16407                         break;
16408
16409                         case REG_DWORD:
16410                         break;
16411
16412                         case REG_MULTI_SZ:
16413                         break;
16414
16415                         default:
16416                         break;
16417
16418                 }
16419         }
16420         return NDR_ERR_SUCCESS;
16421 }
16422
16423 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
16424 {
16425         int level;
16426         level = ndr_print_get_switch_value(ndr, r);
16427         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
16428         switch (level) {
16429                 case REG_NONE:
16430                 break;
16431
16432                 case REG_SZ:
16433                         ndr_print_string(ndr, "string", r->string);
16434                 break;
16435
16436                 case REG_BINARY:
16437                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
16438                 break;
16439
16440                 case REG_DWORD:
16441                         ndr_print_uint32(ndr, "value", r->value);
16442                 break;
16443
16444                 case REG_MULTI_SZ:
16445                         ndr_print_string_array(ndr, "string_array", r->string_array);
16446                 break;
16447
16448                 default:
16449                         ndr_print_DATA_BLOB(ndr, "data", r->data);
16450                 break;
16451
16452         }
16453 }
16454
16455 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
16456 {
16457         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
16458         return NDR_ERR_SUCCESS;
16459 }
16460
16461 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
16462 {
16463         uint32_t v;
16464         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
16465         *r = v;
16466         return NDR_ERR_SUCCESS;
16467 }
16468
16469 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
16470 {
16471         const char *val = NULL;
16472
16473         switch (r) {
16474                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
16475                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
16476                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
16477         }
16478         ndr_print_enum(ndr, name, "ENUM", val, r);
16479 }
16480
16481 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
16482 {
16483         if (ndr_flags & NDR_SCALARS) {
16484                 NDR_CHECK(ndr_push_align(ndr, 4));
16485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
16486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
16487                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16488         }
16489         if (ndr_flags & NDR_BUFFERS) {
16490         }
16491         return NDR_ERR_SUCCESS;
16492 }
16493
16494 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
16495 {
16496         if (ndr_flags & NDR_SCALARS) {
16497                 NDR_CHECK(ndr_pull_align(ndr, 4));
16498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
16499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
16500                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16501         }
16502         if (ndr_flags & NDR_BUFFERS) {
16503         }
16504         return NDR_ERR_SUCCESS;
16505 }
16506
16507 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16508 {
16509         ndr_print_struct(ndr, name, "spoolss_FormSize");
16510         ndr->depth++;
16511         ndr_print_uint32(ndr, "width", r->width);
16512         ndr_print_uint32(ndr, "height", r->height);
16513         ndr->depth--;
16514 }
16515
16516 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16517 {
16518         if (ndr_flags & NDR_SCALARS) {
16519                 NDR_CHECK(ndr_push_align(ndr, 4));
16520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16524                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16525         }
16526         if (ndr_flags & NDR_BUFFERS) {
16527         }
16528         return NDR_ERR_SUCCESS;
16529 }
16530
16531 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16532 {
16533         if (ndr_flags & NDR_SCALARS) {
16534                 NDR_CHECK(ndr_pull_align(ndr, 4));
16535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16539                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16540         }
16541         if (ndr_flags & NDR_BUFFERS) {
16542         }
16543         return NDR_ERR_SUCCESS;
16544 }
16545
16546 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16547 {
16548         ndr_print_struct(ndr, name, "spoolss_FormArea");
16549         ndr->depth++;
16550         ndr_print_uint32(ndr, "left", r->left);
16551         ndr_print_uint32(ndr, "top", r->top);
16552         ndr_print_uint32(ndr, "right", r->right);
16553         ndr_print_uint32(ndr, "bottom", r->bottom);
16554         ndr->depth--;
16555 }
16556
16557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16558 {
16559         if (ndr_flags & NDR_SCALARS) {
16560                 NDR_CHECK(ndr_push_align(ndr, 5));
16561                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16562                 {
16563                         uint32_t _flags_save_string = ndr->flags;
16564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16566                         ndr->flags = _flags_save_string;
16567                 }
16568                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16569                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16570                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16571         }
16572         if (ndr_flags & NDR_BUFFERS) {
16573                 {
16574                         uint32_t _flags_save_string = ndr->flags;
16575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16576                         if (r->form_name) {
16577                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16578                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16579                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16580                         }
16581                         ndr->flags = _flags_save_string;
16582                 }
16583         }
16584         return NDR_ERR_SUCCESS;
16585 }
16586
16587 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16588 {
16589         uint32_t _ptr_form_name;
16590         TALLOC_CTX *_mem_save_form_name_0;
16591         if (ndr_flags & NDR_SCALARS) {
16592                 NDR_CHECK(ndr_pull_align(ndr, 5));
16593                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16594                 {
16595                         uint32_t _flags_save_string = ndr->flags;
16596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16597                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16598                         if (_ptr_form_name) {
16599                                 NDR_PULL_ALLOC(ndr, r->form_name);
16600                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16601                         } else {
16602                                 r->form_name = NULL;
16603                         }
16604                         ndr->flags = _flags_save_string;
16605                 }
16606                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16607                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16609         }
16610         if (ndr_flags & NDR_BUFFERS) {
16611                 {
16612                         uint32_t _flags_save_string = ndr->flags;
16613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16614                         if (r->form_name) {
16615                                 uint32_t _relative_save_offset;
16616                                 _relative_save_offset = ndr->offset;
16617                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16618                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16619                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16620                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16621                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16622                                 if (ndr->offset > ndr->relative_highest_offset) {
16623                                         ndr->relative_highest_offset = ndr->offset;
16624                                 }
16625                                 ndr->offset = _relative_save_offset;
16626                         }
16627                         ndr->flags = _flags_save_string;
16628                 }
16629         }
16630         return NDR_ERR_SUCCESS;
16631 }
16632
16633 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16634 {
16635         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16636         ndr->depth++;
16637         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16638         ndr_print_ptr(ndr, "form_name", r->form_name);
16639         ndr->depth++;
16640         if (r->form_name) {
16641                 ndr_print_string(ndr, "form_name", r->form_name);
16642         }
16643         ndr->depth--;
16644         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16645         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16646         ndr->depth--;
16647 }
16648
16649 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16650 {
16651         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16652 }
16653
16654 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16655 {
16656         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16657         return NDR_ERR_SUCCESS;
16658 }
16659
16660 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16661 {
16662         uint32_t v;
16663         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16664         *r = v;
16665         return NDR_ERR_SUCCESS;
16666 }
16667
16668 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16669 {
16670         ndr_print_uint32(ndr, name, r);
16671         ndr->depth++;
16672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16675         ndr->depth--;
16676 }
16677
16678 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16679 {
16680         if (ndr_flags & NDR_SCALARS) {
16681                 NDR_CHECK(ndr_push_align(ndr, 5));
16682                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16683                 {
16684                         uint32_t _flags_save_string = ndr->flags;
16685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16686                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16687                         ndr->flags = _flags_save_string;
16688                 }
16689                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16690                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16691                 {
16692                         uint32_t _flags_save_string = ndr->flags;
16693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16694                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16695                         ndr->flags = _flags_save_string;
16696                 }
16697                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16698                 {
16699                         uint32_t _flags_save_string = ndr->flags;
16700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16702                         ndr->flags = _flags_save_string;
16703                 }
16704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16705                 {
16706                         uint32_t _flags_save_string = ndr->flags;
16707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16709                         ndr->flags = _flags_save_string;
16710                 }
16711                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16712                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16713                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16714         }
16715         if (ndr_flags & NDR_BUFFERS) {
16716                 {
16717                         uint32_t _flags_save_string = ndr->flags;
16718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16719                         if (r->form_name) {
16720                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->form_name));
16721                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16722                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->form_name));
16723                         }
16724                         ndr->flags = _flags_save_string;
16725                 }
16726                 {
16727                         uint32_t _flags_save_string = ndr->flags;
16728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16729                         if (r->keyword) {
16730                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->keyword));
16731                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16732                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->keyword));
16733                         }
16734                         ndr->flags = _flags_save_string;
16735                 }
16736                 {
16737                         uint32_t _flags_save_string = ndr->flags;
16738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16739                         if (r->mui_dll) {
16740                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->mui_dll));
16741                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16742                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->mui_dll));
16743                         }
16744                         ndr->flags = _flags_save_string;
16745                 }
16746                 {
16747                         uint32_t _flags_save_string = ndr->flags;
16748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16749                         if (r->display_name) {
16750                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->display_name));
16751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16752                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->display_name));
16753                         }
16754                         ndr->flags = _flags_save_string;
16755                 }
16756         }
16757         return NDR_ERR_SUCCESS;
16758 }
16759
16760 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16761 {
16762         uint32_t _ptr_form_name;
16763         TALLOC_CTX *_mem_save_form_name_0;
16764         uint32_t _ptr_keyword;
16765         TALLOC_CTX *_mem_save_keyword_0;
16766         uint32_t _ptr_mui_dll;
16767         TALLOC_CTX *_mem_save_mui_dll_0;
16768         uint32_t _ptr_display_name;
16769         TALLOC_CTX *_mem_save_display_name_0;
16770         if (ndr_flags & NDR_SCALARS) {
16771                 NDR_CHECK(ndr_pull_align(ndr, 5));
16772                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16773                 {
16774                         uint32_t _flags_save_string = ndr->flags;
16775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16777                         if (_ptr_form_name) {
16778                                 NDR_PULL_ALLOC(ndr, r->form_name);
16779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16780                         } else {
16781                                 r->form_name = NULL;
16782                         }
16783                         ndr->flags = _flags_save_string;
16784                 }
16785                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16786                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16787                 {
16788                         uint32_t _flags_save_string = ndr->flags;
16789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16791                         if (_ptr_keyword) {
16792                                 NDR_PULL_ALLOC(ndr, r->keyword);
16793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16794                         } else {
16795                                 r->keyword = NULL;
16796                         }
16797                         ndr->flags = _flags_save_string;
16798                 }
16799                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16800                 {
16801                         uint32_t _flags_save_string = ndr->flags;
16802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16804                         if (_ptr_mui_dll) {
16805                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16807                         } else {
16808                                 r->mui_dll = NULL;
16809                         }
16810                         ndr->flags = _flags_save_string;
16811                 }
16812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16813                 {
16814                         uint32_t _flags_save_string = ndr->flags;
16815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16817                         if (_ptr_display_name) {
16818                                 NDR_PULL_ALLOC(ndr, r->display_name);
16819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16820                         } else {
16821                                 r->display_name = NULL;
16822                         }
16823                         ndr->flags = _flags_save_string;
16824                 }
16825                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16826                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16827                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16828         }
16829         if (ndr_flags & NDR_BUFFERS) {
16830                 {
16831                         uint32_t _flags_save_string = ndr->flags;
16832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16833                         if (r->form_name) {
16834                                 uint32_t _relative_save_offset;
16835                                 _relative_save_offset = ndr->offset;
16836                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16837                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16838                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16839                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16840                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16841                                 if (ndr->offset > ndr->relative_highest_offset) {
16842                                         ndr->relative_highest_offset = ndr->offset;
16843                                 }
16844                                 ndr->offset = _relative_save_offset;
16845                         }
16846                         ndr->flags = _flags_save_string;
16847                 }
16848                 {
16849                         uint32_t _flags_save_string = ndr->flags;
16850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16851                         if (r->keyword) {
16852                                 uint32_t _relative_save_offset;
16853                                 _relative_save_offset = ndr->offset;
16854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16855                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16856                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16859                                 if (ndr->offset > ndr->relative_highest_offset) {
16860                                         ndr->relative_highest_offset = ndr->offset;
16861                                 }
16862                                 ndr->offset = _relative_save_offset;
16863                         }
16864                         ndr->flags = _flags_save_string;
16865                 }
16866                 {
16867                         uint32_t _flags_save_string = ndr->flags;
16868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16869                         if (r->mui_dll) {
16870                                 uint32_t _relative_save_offset;
16871                                 _relative_save_offset = ndr->offset;
16872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16873                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16874                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16877                                 if (ndr->offset > ndr->relative_highest_offset) {
16878                                         ndr->relative_highest_offset = ndr->offset;
16879                                 }
16880                                 ndr->offset = _relative_save_offset;
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->display_name) {
16888                                 uint32_t _relative_save_offset;
16889                                 _relative_save_offset = ndr->offset;
16890                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16891                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16892                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16893                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16894                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16895                                 if (ndr->offset > ndr->relative_highest_offset) {
16896                                         ndr->relative_highest_offset = ndr->offset;
16897                                 }
16898                                 ndr->offset = _relative_save_offset;
16899                         }
16900                         ndr->flags = _flags_save_string;
16901                 }
16902         }
16903         return NDR_ERR_SUCCESS;
16904 }
16905
16906 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16907 {
16908         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16909         ndr->depth++;
16910         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16911         ndr_print_ptr(ndr, "form_name", r->form_name);
16912         ndr->depth++;
16913         if (r->form_name) {
16914                 ndr_print_string(ndr, "form_name", r->form_name);
16915         }
16916         ndr->depth--;
16917         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16918         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16919         ndr_print_ptr(ndr, "keyword", r->keyword);
16920         ndr->depth++;
16921         if (r->keyword) {
16922                 ndr_print_string(ndr, "keyword", r->keyword);
16923         }
16924         ndr->depth--;
16925         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16926         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16927         ndr->depth++;
16928         if (r->mui_dll) {
16929                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16930         }
16931         ndr->depth--;
16932         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16933         ndr_print_ptr(ndr, "display_name", r->display_name);
16934         ndr->depth++;
16935         if (r->display_name) {
16936                 ndr_print_string(ndr, "display_name", r->display_name);
16937         }
16938         ndr->depth--;
16939         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16940         ndr_print_uint16(ndr, "unused", r->unused);
16941         ndr->depth--;
16942 }
16943
16944 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16945 {
16946         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16947 }
16948
16949 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16950 {
16951         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16952         {
16953                 uint32_t _flags_save_UNION = ndr->flags;
16954                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
16955                 if (ndr_flags & NDR_SCALARS) {
16956                         int level = ndr_push_get_switch_value(ndr, r);
16957                         NDR_CHECK(ndr_push_union_align(ndr, 5));
16958                         switch (level) {
16959                                 case 1: {
16960                                         NDR_CHECK(ndr_push_align(ndr, 5));
16961                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16962                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16963                                 break; }
16964
16965                                 case 2: {
16966                                         NDR_CHECK(ndr_push_align(ndr, 5));
16967                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16968                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16969                                 break; }
16970
16971                                 default: {
16972                                 break; }
16973
16974                         }
16975                 }
16976                 if (ndr_flags & NDR_BUFFERS) {
16977                         int level = ndr_push_get_switch_value(ndr, r);
16978                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16979                         switch (level) {
16980                                 case 1:
16981                                         NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16982                                 break;
16983
16984                                 case 2:
16985                                         NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16986                                 break;
16987
16988                                 default:
16989                                 break;
16990
16991                         }
16992                 }
16993                 ndr->flags = _flags_save_UNION;
16994         }
16995         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16996         return NDR_ERR_SUCCESS;
16997 }
16998
16999 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
17000 {
17001         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17002         int level;
17003         {
17004                 uint32_t _flags_save_UNION = ndr->flags;
17005                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17006                 level = ndr_pull_get_switch_value(ndr, r);
17007                 if (ndr_flags & NDR_SCALARS) {
17008                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
17009                         switch (level) {
17010                                 case 1: {
17011                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17012                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17013                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
17014                                 break; }
17015
17016                                 case 2: {
17017                                         NDR_CHECK(ndr_pull_align(ndr, 5));
17018                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17019                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
17020                                 break; }
17021
17022                                 default: {
17023                                 break; }
17024
17025                         }
17026                 }
17027                 if (ndr_flags & NDR_BUFFERS) {
17028                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17029                         switch (level) {
17030                                 case 1:
17031                                         NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
17032                                 break;
17033
17034                                 case 2:
17035                                         NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
17036                                 break;
17037
17038                                 default:
17039                                 break;
17040
17041                         }
17042                 }
17043                 ndr->flags = _flags_save_UNION;
17044         }
17045         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17046         return NDR_ERR_SUCCESS;
17047 }
17048
17049 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
17050 {
17051         int level;
17052         {
17053                 uint32_t _flags_save_UNION = ndr->flags;
17054                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
17055                 level = ndr_print_get_switch_value(ndr, r);
17056                 ndr_print_union(ndr, name, level, "spoolss_FormInfo");
17057                 switch (level) {
17058                         case 1:
17059                                 ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
17060                         break;
17061
17062                         case 2:
17063                                 ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
17064                         break;
17065
17066                         default:
17067                         break;
17068
17069                 }
17070                 ndr->flags = _flags_save_UNION;
17071         }
17072 }
17073
17074 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
17075 {
17076         flags |= LIBNDR_FLAG_RELATIVE_REVERSE;
17077         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
17078 }
17079
17080 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
17081 {
17082         if (ndr_flags & NDR_SCALARS) {
17083                 NDR_CHECK(ndr_push_align(ndr, 5));
17084                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
17085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
17086                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17087                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17088                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17089         }
17090         if (ndr_flags & NDR_BUFFERS) {
17091                 if (r->form_name) {
17092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17096                 }
17097         }
17098         return NDR_ERR_SUCCESS;
17099 }
17100
17101 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
17102 {
17103         uint32_t _ptr_form_name;
17104         TALLOC_CTX *_mem_save_form_name_0;
17105         if (ndr_flags & NDR_SCALARS) {
17106                 NDR_CHECK(ndr_pull_align(ndr, 5));
17107                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
17108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
17109                 if (_ptr_form_name) {
17110                         NDR_PULL_ALLOC(ndr, r->form_name);
17111                 } else {
17112                         r->form_name = NULL;
17113                 }
17114                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17115                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17116                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17117         }
17118         if (ndr_flags & NDR_BUFFERS) {
17119                 if (r->form_name) {
17120                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17121                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
17122                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
17123                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
17124                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
17125                                 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));
17126                         }
17127                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
17128                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
17129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
17130                 }
17131         }
17132         return NDR_ERR_SUCCESS;
17133 }
17134
17135 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
17136 {
17137         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
17138         ndr->depth++;
17139         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
17140         ndr_print_ptr(ndr, "form_name", r->form_name);
17141         ndr->depth++;
17142         if (r->form_name) {
17143                 ndr_print_string(ndr, "form_name", r->form_name);
17144         }
17145         ndr->depth--;
17146         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
17147         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
17148         ndr->depth--;
17149 }
17150
17151 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
17152 {
17153         if (ndr_flags & NDR_SCALARS) {
17154                 NDR_CHECK(ndr_push_align(ndr, 5));
17155                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
17156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
17157                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17158                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
17160                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
17161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
17162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
17163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
17164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
17165                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17166         }
17167         if (ndr_flags & NDR_BUFFERS) {
17168                 if (r->form_name) {
17169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
17172                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17173                 }
17174                 if (r->keyword) {
17175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
17176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
17178                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
17179                 }
17180                 if (r->mui_dll) {
17181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
17182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
17184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17185                 }
17186                 if (r->display_name) {
17187                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
17188                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
17189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
17190                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17191                 }
17192         }
17193         return NDR_ERR_SUCCESS;
17194 }
17195
17196 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
17197 {
17198         uint32_t _ptr_form_name;
17199         TALLOC_CTX *_mem_save_form_name_0;
17200         uint32_t _ptr_keyword;
17201         TALLOC_CTX *_mem_save_keyword_0;
17202         uint32_t _ptr_mui_dll;
17203         TALLOC_CTX *_mem_save_mui_dll_0;
17204         uint32_t _ptr_display_name;
17205         TALLOC_CTX *_mem_save_display_name_0;
17206         if (ndr_flags & NDR_SCALARS) {
17207                 NDR_CHECK(ndr_pull_align(ndr, 5));
17208                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
17209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
17210                 if (_ptr_form_name) {
17211                         NDR_PULL_ALLOC(ndr, r->form_name);
17212                 } else {
17213                         r->form_name = NULL;
17214                 }
17215                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
17216                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
17217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
17218                 if (_ptr_keyword) {
17219                         NDR_PULL_ALLOC(ndr, r->keyword);
17220                 } else {
17221                         r->keyword = NULL;
17222                 }
17223                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
17224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
17225                 if (_ptr_mui_dll) {
17226                         NDR_PULL_ALLOC(ndr, r->mui_dll);
17227                 } else {
17228                         r->mui_dll = NULL;
17229                 }
17230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
17231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
17232                 if (_ptr_display_name) {
17233                         NDR_PULL_ALLOC(ndr, r->display_name);
17234                 } else {
17235                         r->display_name = NULL;
17236                 }
17237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
17238                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17239         }
17240         if (ndr_flags & NDR_BUFFERS) {
17241                 if (r->form_name) {
17242                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17243                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
17244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
17245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
17246                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
17247                                 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));
17248                         }
17249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
17250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
17251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
17252                 }
17253                 if (r->keyword) {
17254                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
17255                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
17256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
17257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
17258                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
17259                                 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));
17260                         }
17261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
17262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
17263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
17264                 }
17265                 if (r->mui_dll) {
17266                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
17267                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
17268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
17269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
17270                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
17271                                 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));
17272                         }
17273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
17274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
17275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
17276                 }
17277                 if (r->display_name) {
17278                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17279                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
17280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
17281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
17282                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
17283                                 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));
17284                         }
17285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
17286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
17287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
17288                 }
17289         }
17290         return NDR_ERR_SUCCESS;
17291 }
17292
17293 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
17294 {
17295         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
17296         ndr->depth++;
17297         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
17298         ndr_print_ptr(ndr, "form_name", r->form_name);
17299         ndr->depth++;
17300         if (r->form_name) {
17301                 ndr_print_string(ndr, "form_name", r->form_name);
17302         }
17303         ndr->depth--;
17304         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
17305         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
17306         ndr_print_ptr(ndr, "keyword", r->keyword);
17307         ndr->depth++;
17308         if (r->keyword) {
17309                 ndr_print_string(ndr, "keyword", r->keyword);
17310         }
17311         ndr->depth--;
17312         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
17313         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
17314         ndr->depth++;
17315         if (r->mui_dll) {
17316                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
17317         }
17318         ndr->depth--;
17319         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
17320         ndr_print_ptr(ndr, "display_name", r->display_name);
17321         ndr->depth++;
17322         if (r->display_name) {
17323                 ndr_print_string(ndr, "display_name", r->display_name);
17324         }
17325         ndr->depth--;
17326         ndr_print_uint32(ndr, "lang_id", r->lang_id);
17327         ndr->depth--;
17328 }
17329
17330 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
17331 {
17332         if (ndr_flags & NDR_SCALARS) {
17333                 int level = ndr_push_get_switch_value(ndr, r);
17334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17335                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17336                 switch (level) {
17337                         case 1: {
17338                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
17339                         break; }
17340
17341                         case 2: {
17342                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
17343                         break; }
17344
17345                         default:
17346                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17347                 }
17348         }
17349         if (ndr_flags & NDR_BUFFERS) {
17350                 int level = ndr_push_get_switch_value(ndr, r);
17351                 switch (level) {
17352                         case 1:
17353                                 if (r->info1) {
17354                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17355                                 }
17356                         break;
17357
17358                         case 2:
17359                                 if (r->info2) {
17360                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17361                                 }
17362                         break;
17363
17364                         default:
17365                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17366                 }
17367         }
17368         return NDR_ERR_SUCCESS;
17369 }
17370
17371 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
17372 {
17373         int level;
17374         uint32_t _level;
17375         TALLOC_CTX *_mem_save_info1_0;
17376         TALLOC_CTX *_mem_save_info2_0;
17377         level = ndr_pull_get_switch_value(ndr, r);
17378         if (ndr_flags & NDR_SCALARS) {
17379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17380                 if (_level != level) {
17381                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
17382                 }
17383                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17384                 switch (level) {
17385                         case 1: {
17386                                 uint32_t _ptr_info1;
17387                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
17388                                 if (_ptr_info1) {
17389                                         NDR_PULL_ALLOC(ndr, r->info1);
17390                                 } else {
17391                                         r->info1 = NULL;
17392                                 }
17393                         break; }
17394
17395                         case 2: {
17396                                 uint32_t _ptr_info2;
17397                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
17398                                 if (_ptr_info2) {
17399                                         NDR_PULL_ALLOC(ndr, r->info2);
17400                                 } else {
17401                                         r->info2 = NULL;
17402                                 }
17403                         break; }
17404
17405                         default:
17406                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17407                 }
17408         }
17409         if (ndr_flags & NDR_BUFFERS) {
17410                 switch (level) {
17411                         case 1:
17412                                 if (r->info1) {
17413                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
17414                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
17415                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
17416                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
17417                                 }
17418                         break;
17419
17420                         case 2:
17421                                 if (r->info2) {
17422                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
17423                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
17424                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
17425                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
17426                                 }
17427                         break;
17428
17429                         default:
17430                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
17431                 }
17432         }
17433         return NDR_ERR_SUCCESS;
17434 }
17435
17436 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
17437 {
17438         int level;
17439         level = ndr_print_get_switch_value(ndr, r);
17440         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
17441         switch (level) {
17442                 case 1:
17443                         ndr_print_ptr(ndr, "info1", r->info1);
17444                         ndr->depth++;
17445                         if (r->info1) {
17446                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
17447                         }
17448                         ndr->depth--;
17449                 break;
17450
17451                 case 2:
17452                         ndr_print_ptr(ndr, "info2", r->info2);
17453                         ndr->depth++;
17454                         if (r->info2) {
17455                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
17456                         }
17457                         ndr->depth--;
17458                 break;
17459
17460                 default:
17461                         ndr_print_bad_level(ndr, name, level);
17462         }
17463 }
17464
17465 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
17466 {
17467         if (ndr_flags & NDR_SCALARS) {
17468                 NDR_CHECK(ndr_push_align(ndr, 5));
17469                 {
17470                         uint32_t _flags_save_string = ndr->flags;
17471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17472                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17473                         ndr->flags = _flags_save_string;
17474                 }
17475                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17476         }
17477         if (ndr_flags & NDR_BUFFERS) {
17478                 {
17479                         uint32_t _flags_save_string = ndr->flags;
17480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17481                         if (r->port_name) {
17482                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17483                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17484                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17485                         }
17486                         ndr->flags = _flags_save_string;
17487                 }
17488         }
17489         return NDR_ERR_SUCCESS;
17490 }
17491
17492 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
17493 {
17494         uint32_t _ptr_port_name;
17495         TALLOC_CTX *_mem_save_port_name_0;
17496         if (ndr_flags & NDR_SCALARS) {
17497                 NDR_CHECK(ndr_pull_align(ndr, 5));
17498                 {
17499                         uint32_t _flags_save_string = ndr->flags;
17500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17502                         if (_ptr_port_name) {
17503                                 NDR_PULL_ALLOC(ndr, r->port_name);
17504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17505                         } else {
17506                                 r->port_name = NULL;
17507                         }
17508                         ndr->flags = _flags_save_string;
17509                 }
17510                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17511         }
17512         if (ndr_flags & NDR_BUFFERS) {
17513                 {
17514                         uint32_t _flags_save_string = ndr->flags;
17515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17516                         if (r->port_name) {
17517                                 uint32_t _relative_save_offset;
17518                                 _relative_save_offset = ndr->offset;
17519                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17520                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17521                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17522                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17523                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17524                                 if (ndr->offset > ndr->relative_highest_offset) {
17525                                         ndr->relative_highest_offset = ndr->offset;
17526                                 }
17527                                 ndr->offset = _relative_save_offset;
17528                         }
17529                         ndr->flags = _flags_save_string;
17530                 }
17531         }
17532         return NDR_ERR_SUCCESS;
17533 }
17534
17535 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17536 {
17537         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17538         ndr->depth++;
17539         ndr_print_ptr(ndr, "port_name", r->port_name);
17540         ndr->depth++;
17541         if (r->port_name) {
17542                 ndr_print_string(ndr, "port_name", r->port_name);
17543         }
17544         ndr->depth--;
17545         ndr->depth--;
17546 }
17547
17548 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17549 {
17550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17551 }
17552
17553 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17554 {
17555         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17556         return NDR_ERR_SUCCESS;
17557 }
17558
17559 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17560 {
17561         uint32_t v;
17562         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17563         *r = v;
17564         return NDR_ERR_SUCCESS;
17565 }
17566
17567 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17568 {
17569         ndr_print_uint32(ndr, name, r);
17570         ndr->depth++;
17571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17575         ndr->depth--;
17576 }
17577
17578 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17579 {
17580         if (ndr_flags & NDR_SCALARS) {
17581                 NDR_CHECK(ndr_push_align(ndr, 5));
17582                 {
17583                         uint32_t _flags_save_string = ndr->flags;
17584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17586                         ndr->flags = _flags_save_string;
17587                 }
17588                 {
17589                         uint32_t _flags_save_string = ndr->flags;
17590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17592                         ndr->flags = _flags_save_string;
17593                 }
17594                 {
17595                         uint32_t _flags_save_string = ndr->flags;
17596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17598                         ndr->flags = _flags_save_string;
17599                 }
17600                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17603         }
17604         if (ndr_flags & NDR_BUFFERS) {
17605                 {
17606                         uint32_t _flags_save_string = ndr->flags;
17607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17608                         if (r->port_name) {
17609                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17611                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17612                         }
17613                         ndr->flags = _flags_save_string;
17614                 }
17615                 {
17616                         uint32_t _flags_save_string = ndr->flags;
17617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17618                         if (r->monitor_name) {
17619                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
17620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17621                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
17622                         }
17623                         ndr->flags = _flags_save_string;
17624                 }
17625                 {
17626                         uint32_t _flags_save_string = ndr->flags;
17627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17628                         if (r->description) {
17629                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->description));
17630                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17631                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->description));
17632                         }
17633                         ndr->flags = _flags_save_string;
17634                 }
17635         }
17636         return NDR_ERR_SUCCESS;
17637 }
17638
17639 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17640 {
17641         uint32_t _ptr_port_name;
17642         TALLOC_CTX *_mem_save_port_name_0;
17643         uint32_t _ptr_monitor_name;
17644         TALLOC_CTX *_mem_save_monitor_name_0;
17645         uint32_t _ptr_description;
17646         TALLOC_CTX *_mem_save_description_0;
17647         if (ndr_flags & NDR_SCALARS) {
17648                 NDR_CHECK(ndr_pull_align(ndr, 5));
17649                 {
17650                         uint32_t _flags_save_string = ndr->flags;
17651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17652                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17653                         if (_ptr_port_name) {
17654                                 NDR_PULL_ALLOC(ndr, r->port_name);
17655                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17656                         } else {
17657                                 r->port_name = NULL;
17658                         }
17659                         ndr->flags = _flags_save_string;
17660                 }
17661                 {
17662                         uint32_t _flags_save_string = ndr->flags;
17663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17665                         if (_ptr_monitor_name) {
17666                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17667                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17668                         } else {
17669                                 r->monitor_name = NULL;
17670                         }
17671                         ndr->flags = _flags_save_string;
17672                 }
17673                 {
17674                         uint32_t _flags_save_string = ndr->flags;
17675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17676                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17677                         if (_ptr_description) {
17678                                 NDR_PULL_ALLOC(ndr, r->description);
17679                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17680                         } else {
17681                                 r->description = NULL;
17682                         }
17683                         ndr->flags = _flags_save_string;
17684                 }
17685                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17687                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17688         }
17689         if (ndr_flags & NDR_BUFFERS) {
17690                 {
17691                         uint32_t _flags_save_string = ndr->flags;
17692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17693                         if (r->port_name) {
17694                                 uint32_t _relative_save_offset;
17695                                 _relative_save_offset = ndr->offset;
17696                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17697                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17698                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17699                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17700                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17701                                 if (ndr->offset > ndr->relative_highest_offset) {
17702                                         ndr->relative_highest_offset = ndr->offset;
17703                                 }
17704                                 ndr->offset = _relative_save_offset;
17705                         }
17706                         ndr->flags = _flags_save_string;
17707                 }
17708                 {
17709                         uint32_t _flags_save_string = ndr->flags;
17710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17711                         if (r->monitor_name) {
17712                                 uint32_t _relative_save_offset;
17713                                 _relative_save_offset = ndr->offset;
17714                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17715                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17716                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17717                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17718                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17719                                 if (ndr->offset > ndr->relative_highest_offset) {
17720                                         ndr->relative_highest_offset = ndr->offset;
17721                                 }
17722                                 ndr->offset = _relative_save_offset;
17723                         }
17724                         ndr->flags = _flags_save_string;
17725                 }
17726                 {
17727                         uint32_t _flags_save_string = ndr->flags;
17728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17729                         if (r->description) {
17730                                 uint32_t _relative_save_offset;
17731                                 _relative_save_offset = ndr->offset;
17732                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17733                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17734                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17735                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17736                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17737                                 if (ndr->offset > ndr->relative_highest_offset) {
17738                                         ndr->relative_highest_offset = ndr->offset;
17739                                 }
17740                                 ndr->offset = _relative_save_offset;
17741                         }
17742                         ndr->flags = _flags_save_string;
17743                 }
17744         }
17745         return NDR_ERR_SUCCESS;
17746 }
17747
17748 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17749 {
17750         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17751         ndr->depth++;
17752         ndr_print_ptr(ndr, "port_name", r->port_name);
17753         ndr->depth++;
17754         if (r->port_name) {
17755                 ndr_print_string(ndr, "port_name", r->port_name);
17756         }
17757         ndr->depth--;
17758         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17759         ndr->depth++;
17760         if (r->monitor_name) {
17761                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17762         }
17763         ndr->depth--;
17764         ndr_print_ptr(ndr, "description", r->description);
17765         ndr->depth++;
17766         if (r->description) {
17767                 ndr_print_string(ndr, "description", r->description);
17768         }
17769         ndr->depth--;
17770         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17771         ndr_print_uint32(ndr, "reserved", r->reserved);
17772         ndr->depth--;
17773 }
17774
17775 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17776 {
17777         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17778 }
17779
17780 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17781 {
17782         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17783         return NDR_ERR_SUCCESS;
17784 }
17785
17786 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17787 {
17788         uint32_t v;
17789         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17790         *r = v;
17791         return NDR_ERR_SUCCESS;
17792 }
17793
17794 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17795 {
17796         const char *val = NULL;
17797
17798         switch (r) {
17799                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17800                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17801                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17802                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17803                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17804                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17805                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17806                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17807                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17808                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17809                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17810                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17811                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17812         }
17813         ndr_print_enum(ndr, name, "ENUM", val, r);
17814 }
17815
17816 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17817 {
17818         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17819         return NDR_ERR_SUCCESS;
17820 }
17821
17822 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17823 {
17824         uint32_t v;
17825         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17826         *r = v;
17827         return NDR_ERR_SUCCESS;
17828 }
17829
17830 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17831 {
17832         const char *val = NULL;
17833
17834         switch (r) {
17835                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17836                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17837                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17838         }
17839         ndr_print_enum(ndr, name, "ENUM", val, r);
17840 }
17841
17842 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17843 {
17844         if (ndr_flags & NDR_SCALARS) {
17845                 NDR_CHECK(ndr_push_align(ndr, 5));
17846                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17847                 {
17848                         uint32_t _flags_save_string = ndr->flags;
17849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17851                         ndr->flags = _flags_save_string;
17852                 }
17853                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17854                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17855         }
17856         if (ndr_flags & NDR_BUFFERS) {
17857                 {
17858                         uint32_t _flags_save_string = ndr->flags;
17859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17860                         if (r->status_string) {
17861                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->status_string));
17862                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17863                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->status_string));
17864                         }
17865                         ndr->flags = _flags_save_string;
17866                 }
17867         }
17868         return NDR_ERR_SUCCESS;
17869 }
17870
17871 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17872 {
17873         uint32_t _ptr_status_string;
17874         TALLOC_CTX *_mem_save_status_string_0;
17875         if (ndr_flags & NDR_SCALARS) {
17876                 NDR_CHECK(ndr_pull_align(ndr, 5));
17877                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17878                 {
17879                         uint32_t _flags_save_string = ndr->flags;
17880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17881                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17882                         if (_ptr_status_string) {
17883                                 NDR_PULL_ALLOC(ndr, r->status_string);
17884                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17885                         } else {
17886                                 r->status_string = NULL;
17887                         }
17888                         ndr->flags = _flags_save_string;
17889                 }
17890                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17891                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17892         }
17893         if (ndr_flags & NDR_BUFFERS) {
17894                 {
17895                         uint32_t _flags_save_string = ndr->flags;
17896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17897                         if (r->status_string) {
17898                                 uint32_t _relative_save_offset;
17899                                 _relative_save_offset = ndr->offset;
17900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17901                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17902                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17905                                 if (ndr->offset > ndr->relative_highest_offset) {
17906                                         ndr->relative_highest_offset = ndr->offset;
17907                                 }
17908                                 ndr->offset = _relative_save_offset;
17909                         }
17910                         ndr->flags = _flags_save_string;
17911                 }
17912         }
17913         return NDR_ERR_SUCCESS;
17914 }
17915
17916 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17917 {
17918         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17919         ndr->depth++;
17920         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17921         ndr_print_ptr(ndr, "status_string", r->status_string);
17922         ndr->depth++;
17923         if (r->status_string) {
17924                 ndr_print_string(ndr, "status_string", r->status_string);
17925         }
17926         ndr->depth--;
17927         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17928         ndr->depth--;
17929 }
17930
17931 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17932 {
17933         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17934 }
17935
17936 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17937 {
17938         if (ndr_flags & NDR_SCALARS) {
17939                 NDR_CHECK(ndr_push_align(ndr, 5));
17940                 {
17941                         uint32_t _flags_save_string = ndr->flags;
17942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17944                         ndr->flags = _flags_save_string;
17945                 }
17946                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17947                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17948         }
17949         if (ndr_flags & NDR_BUFFERS) {
17950                 {
17951                         uint32_t _flags_save_string = ndr->flags;
17952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17953                         if (r->port_name) {
17954                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->port_name));
17955                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17956                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->port_name));
17957                         }
17958                         ndr->flags = _flags_save_string;
17959                 }
17960         }
17961         return NDR_ERR_SUCCESS;
17962 }
17963
17964 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17965 {
17966         uint32_t _ptr_port_name;
17967         TALLOC_CTX *_mem_save_port_name_0;
17968         if (ndr_flags & NDR_SCALARS) {
17969                 NDR_CHECK(ndr_pull_align(ndr, 5));
17970                 {
17971                         uint32_t _flags_save_string = ndr->flags;
17972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17973                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17974                         if (_ptr_port_name) {
17975                                 NDR_PULL_ALLOC(ndr, r->port_name);
17976                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17977                         } else {
17978                                 r->port_name = NULL;
17979                         }
17980                         ndr->flags = _flags_save_string;
17981                 }
17982                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17983                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17984         }
17985         if (ndr_flags & NDR_BUFFERS) {
17986                 {
17987                         uint32_t _flags_save_string = ndr->flags;
17988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17989                         if (r->port_name) {
17990                                 uint32_t _relative_save_offset;
17991                                 _relative_save_offset = ndr->offset;
17992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17993                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17994                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17997                                 if (ndr->offset > ndr->relative_highest_offset) {
17998                                         ndr->relative_highest_offset = ndr->offset;
17999                                 }
18000                                 ndr->offset = _relative_save_offset;
18001                         }
18002                         ndr->flags = _flags_save_string;
18003                 }
18004         }
18005         return NDR_ERR_SUCCESS;
18006 }
18007
18008 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
18009 {
18010         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
18011         ndr->depth++;
18012         ndr_print_ptr(ndr, "port_name", r->port_name);
18013         ndr->depth++;
18014         if (r->port_name) {
18015                 ndr_print_string(ndr, "port_name", r->port_name);
18016         }
18017         ndr->depth--;
18018         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
18019         ndr->depth--;
18020 }
18021
18022 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
18023 {
18024         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
18025 }
18026
18027 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
18028 {
18029         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18030         {
18031                 uint32_t _flags_save_UNION = ndr->flags;
18032                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18033                 if (ndr_flags & NDR_SCALARS) {
18034                         int level = ndr_push_get_switch_value(ndr, r);
18035                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18036                         switch (level) {
18037                                 case 1: {
18038                                         NDR_CHECK(ndr_push_align(ndr, 5));
18039                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18040                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
18041                                 break; }
18042
18043                                 case 2: {
18044                                         NDR_CHECK(ndr_push_align(ndr, 5));
18045                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18046                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
18047                                 break; }
18048
18049                                 case 3: {
18050                                         NDR_CHECK(ndr_push_align(ndr, 5));
18051                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18052                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
18053                                 break; }
18054
18055                                 case 0xff: {
18056                                         NDR_CHECK(ndr_push_align(ndr, 5));
18057                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18058                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
18059                                 break; }
18060
18061                                 default: {
18062                                 break; }
18063
18064                         }
18065                 }
18066                 if (ndr_flags & NDR_BUFFERS) {
18067                         int level = ndr_push_get_switch_value(ndr, r);
18068                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18069                         switch (level) {
18070                                 case 1:
18071                                         NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
18072                                 break;
18073
18074                                 case 2:
18075                                         NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
18076                                 break;
18077
18078                                 case 3:
18079                                         NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
18080                                 break;
18081
18082                                 case 0xff:
18083                                         NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
18084                                 break;
18085
18086                                 default:
18087                                 break;
18088
18089                         }
18090                 }
18091                 ndr->flags = _flags_save_UNION;
18092         }
18093         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18094         return NDR_ERR_SUCCESS;
18095 }
18096
18097 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
18098 {
18099         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18100         int level;
18101         {
18102                 uint32_t _flags_save_UNION = ndr->flags;
18103                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18104                 level = ndr_pull_get_switch_value(ndr, r);
18105                 if (ndr_flags & NDR_SCALARS) {
18106                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18107                         switch (level) {
18108                                 case 1: {
18109                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18110                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18111                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
18112                                 break; }
18113
18114                                 case 2: {
18115                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18116                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18117                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
18118                                 break; }
18119
18120                                 case 3: {
18121                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18122                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18123                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
18124                                 break; }
18125
18126                                 case 0xff: {
18127                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18128                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18129                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
18130                                 break; }
18131
18132                                 default: {
18133                                 break; }
18134
18135                         }
18136                 }
18137                 if (ndr_flags & NDR_BUFFERS) {
18138                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18139                         switch (level) {
18140                                 case 1:
18141                                         NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
18142                                 break;
18143
18144                                 case 2:
18145                                         NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
18146                                 break;
18147
18148                                 case 3:
18149                                         NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
18150                                 break;
18151
18152                                 case 0xff:
18153                                         NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
18154                                 break;
18155
18156                                 default:
18157                                 break;
18158
18159                         }
18160                 }
18161                 ndr->flags = _flags_save_UNION;
18162         }
18163         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18164         return NDR_ERR_SUCCESS;
18165 }
18166
18167 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
18168 {
18169         int level;
18170         {
18171                 uint32_t _flags_save_UNION = ndr->flags;
18172                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18173                 level = ndr_print_get_switch_value(ndr, r);
18174                 ndr_print_union(ndr, name, level, "spoolss_PortInfo");
18175                 switch (level) {
18176                         case 1:
18177                                 ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
18178                         break;
18179
18180                         case 2:
18181                                 ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
18182                         break;
18183
18184                         case 3:
18185                                 ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
18186                         break;
18187
18188                         case 0xff:
18189                                 ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
18190                         break;
18191
18192                         default:
18193                         break;
18194
18195                 }
18196                 ndr->flags = _flags_save_UNION;
18197         }
18198 }
18199
18200 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
18201 {
18202         if (ndr_flags & NDR_SCALARS) {
18203                 NDR_CHECK(ndr_push_align(ndr, 5));
18204                 {
18205                         uint32_t _flags_save_string = ndr->flags;
18206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18207                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
18208                         ndr->flags = _flags_save_string;
18209                 }
18210                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18211         }
18212         if (ndr_flags & NDR_BUFFERS) {
18213                 {
18214                         uint32_t _flags_save_string = ndr->flags;
18215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18216                         if (r->monitor_name) {
18217                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
18218                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
18219                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
18220                         }
18221                         ndr->flags = _flags_save_string;
18222                 }
18223         }
18224         return NDR_ERR_SUCCESS;
18225 }
18226
18227 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
18228 {
18229         uint32_t _ptr_monitor_name;
18230         TALLOC_CTX *_mem_save_monitor_name_0;
18231         if (ndr_flags & NDR_SCALARS) {
18232                 NDR_CHECK(ndr_pull_align(ndr, 5));
18233                 {
18234                         uint32_t _flags_save_string = ndr->flags;
18235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18237                         if (_ptr_monitor_name) {
18238                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18240                         } else {
18241                                 r->monitor_name = NULL;
18242                         }
18243                         ndr->flags = _flags_save_string;
18244                 }
18245                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18246         }
18247         if (ndr_flags & NDR_BUFFERS) {
18248                 {
18249                         uint32_t _flags_save_string = ndr->flags;
18250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18251                         if (r->monitor_name) {
18252                                 uint32_t _relative_save_offset;
18253                                 _relative_save_offset = ndr->offset;
18254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18255                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18256                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18257                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18259                                 if (ndr->offset > ndr->relative_highest_offset) {
18260                                         ndr->relative_highest_offset = ndr->offset;
18261                                 }
18262                                 ndr->offset = _relative_save_offset;
18263                         }
18264                         ndr->flags = _flags_save_string;
18265                 }
18266         }
18267         return NDR_ERR_SUCCESS;
18268 }
18269
18270 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
18271 {
18272         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
18273         ndr->depth++;
18274         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18275         ndr->depth++;
18276         if (r->monitor_name) {
18277                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18278         }
18279         ndr->depth--;
18280         ndr->depth--;
18281 }
18282
18283 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18284 {
18285         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
18286 }
18287
18288 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
18289 {
18290         if (ndr_flags & NDR_SCALARS) {
18291                 NDR_CHECK(ndr_push_align(ndr, 5));
18292                 {
18293                         uint32_t _flags_save_string = ndr->flags;
18294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18295                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
18296                         ndr->flags = _flags_save_string;
18297                 }
18298                 {
18299                         uint32_t _flags_save_string = ndr->flags;
18300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18301                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
18302                         ndr->flags = _flags_save_string;
18303                 }
18304                 {
18305                         uint32_t _flags_save_string = ndr->flags;
18306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18307                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
18308                         ndr->flags = _flags_save_string;
18309                 }
18310                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18311         }
18312         if (ndr_flags & NDR_BUFFERS) {
18313                 {
18314                         uint32_t _flags_save_string = ndr->flags;
18315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18316                         if (r->monitor_name) {
18317                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
18318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
18319                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
18320                         }
18321                         ndr->flags = _flags_save_string;
18322                 }
18323                 {
18324                         uint32_t _flags_save_string = ndr->flags;
18325                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18326                         if (r->environment) {
18327                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->environment));
18328                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
18329                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->environment));
18330                         }
18331                         ndr->flags = _flags_save_string;
18332                 }
18333                 {
18334                         uint32_t _flags_save_string = ndr->flags;
18335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18336                         if (r->dll_name) {
18337                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dll_name));
18338                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18339                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dll_name));
18340                         }
18341                         ndr->flags = _flags_save_string;
18342                 }
18343         }
18344         return NDR_ERR_SUCCESS;
18345 }
18346
18347 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
18348 {
18349         uint32_t _ptr_monitor_name;
18350         TALLOC_CTX *_mem_save_monitor_name_0;
18351         uint32_t _ptr_environment;
18352         TALLOC_CTX *_mem_save_environment_0;
18353         uint32_t _ptr_dll_name;
18354         TALLOC_CTX *_mem_save_dll_name_0;
18355         if (ndr_flags & NDR_SCALARS) {
18356                 NDR_CHECK(ndr_pull_align(ndr, 5));
18357                 {
18358                         uint32_t _flags_save_string = ndr->flags;
18359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18360                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
18361                         if (_ptr_monitor_name) {
18362                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
18363                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
18364                         } else {
18365                                 r->monitor_name = NULL;
18366                         }
18367                         ndr->flags = _flags_save_string;
18368                 }
18369                 {
18370                         uint32_t _flags_save_string = ndr->flags;
18371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18372                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18373                         if (_ptr_environment) {
18374                                 NDR_PULL_ALLOC(ndr, r->environment);
18375                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
18376                         } else {
18377                                 r->environment = NULL;
18378                         }
18379                         ndr->flags = _flags_save_string;
18380                 }
18381                 {
18382                         uint32_t _flags_save_string = ndr->flags;
18383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18384                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
18385                         if (_ptr_dll_name) {
18386                                 NDR_PULL_ALLOC(ndr, r->dll_name);
18387                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
18388                         } else {
18389                                 r->dll_name = NULL;
18390                         }
18391                         ndr->flags = _flags_save_string;
18392                 }
18393                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18394         }
18395         if (ndr_flags & NDR_BUFFERS) {
18396                 {
18397                         uint32_t _flags_save_string = ndr->flags;
18398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18399                         if (r->monitor_name) {
18400                                 uint32_t _relative_save_offset;
18401                                 _relative_save_offset = ndr->offset;
18402                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
18403                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18404                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
18405                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
18406                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
18407                                 if (ndr->offset > ndr->relative_highest_offset) {
18408                                         ndr->relative_highest_offset = ndr->offset;
18409                                 }
18410                                 ndr->offset = _relative_save_offset;
18411                         }
18412                         ndr->flags = _flags_save_string;
18413                 }
18414                 {
18415                         uint32_t _flags_save_string = ndr->flags;
18416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18417                         if (r->environment) {
18418                                 uint32_t _relative_save_offset;
18419                                 _relative_save_offset = ndr->offset;
18420                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
18421                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18422                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
18423                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
18424                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18425                                 if (ndr->offset > ndr->relative_highest_offset) {
18426                                         ndr->relative_highest_offset = ndr->offset;
18427                                 }
18428                                 ndr->offset = _relative_save_offset;
18429                         }
18430                         ndr->flags = _flags_save_string;
18431                 }
18432                 {
18433                         uint32_t _flags_save_string = ndr->flags;
18434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18435                         if (r->dll_name) {
18436                                 uint32_t _relative_save_offset;
18437                                 _relative_save_offset = ndr->offset;
18438                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
18439                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18440                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
18441                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18442                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
18443                                 if (ndr->offset > ndr->relative_highest_offset) {
18444                                         ndr->relative_highest_offset = ndr->offset;
18445                                 }
18446                                 ndr->offset = _relative_save_offset;
18447                         }
18448                         ndr->flags = _flags_save_string;
18449                 }
18450         }
18451         return NDR_ERR_SUCCESS;
18452 }
18453
18454 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
18455 {
18456         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
18457         ndr->depth++;
18458         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
18459         ndr->depth++;
18460         if (r->monitor_name) {
18461                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
18462         }
18463         ndr->depth--;
18464         ndr_print_ptr(ndr, "environment", r->environment);
18465         ndr->depth++;
18466         if (r->environment) {
18467                 ndr_print_string(ndr, "environment", r->environment);
18468         }
18469         ndr->depth--;
18470         ndr_print_ptr(ndr, "dll_name", r->dll_name);
18471         ndr->depth++;
18472         if (r->dll_name) {
18473                 ndr_print_string(ndr, "dll_name", r->dll_name);
18474         }
18475         ndr->depth--;
18476         ndr->depth--;
18477 }
18478
18479 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
18480 {
18481         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
18482 }
18483
18484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
18485 {
18486         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18487         {
18488                 uint32_t _flags_save_UNION = ndr->flags;
18489                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18490                 if (ndr_flags & NDR_SCALARS) {
18491                         int level = ndr_push_get_switch_value(ndr, r);
18492                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18493                         switch (level) {
18494                                 case 1: {
18495                                         NDR_CHECK(ndr_push_align(ndr, 5));
18496                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18497                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18498                                 break; }
18499
18500                                 case 2: {
18501                                         NDR_CHECK(ndr_push_align(ndr, 5));
18502                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18503                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18504                                 break; }
18505
18506                                 default: {
18507                                 break; }
18508
18509                         }
18510                 }
18511                 if (ndr_flags & NDR_BUFFERS) {
18512                         int level = ndr_push_get_switch_value(ndr, r);
18513                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18514                         switch (level) {
18515                                 case 1:
18516                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18517                                 break;
18518
18519                                 case 2:
18520                                         NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18521                                 break;
18522
18523                                 default:
18524                                 break;
18525
18526                         }
18527                 }
18528                 ndr->flags = _flags_save_UNION;
18529         }
18530         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18531         return NDR_ERR_SUCCESS;
18532 }
18533
18534 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
18535 {
18536         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18537         int level;
18538         {
18539                 uint32_t _flags_save_UNION = ndr->flags;
18540                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18541                 level = ndr_pull_get_switch_value(ndr, r);
18542                 if (ndr_flags & NDR_SCALARS) {
18543                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18544                         switch (level) {
18545                                 case 1: {
18546                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18547                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18548                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
18549                                 break; }
18550
18551                                 case 2: {
18552                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18553                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18554                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
18555                                 break; }
18556
18557                                 default: {
18558                                 break; }
18559
18560                         }
18561                 }
18562                 if (ndr_flags & NDR_BUFFERS) {
18563                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18564                         switch (level) {
18565                                 case 1:
18566                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18567                                 break;
18568
18569                                 case 2:
18570                                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18571                                 break;
18572
18573                                 default:
18574                                 break;
18575
18576                         }
18577                 }
18578                 ndr->flags = _flags_save_UNION;
18579         }
18580         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18581         return NDR_ERR_SUCCESS;
18582 }
18583
18584 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18585 {
18586         int level;
18587         {
18588                 uint32_t _flags_save_UNION = ndr->flags;
18589                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18590                 level = ndr_print_get_switch_value(ndr, r);
18591                 ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18592                 switch (level) {
18593                         case 1:
18594                                 ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18595                         break;
18596
18597                         case 2:
18598                                 ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18599                         break;
18600
18601                         default:
18602                         break;
18603
18604                 }
18605                 ndr->flags = _flags_save_UNION;
18606         }
18607 }
18608
18609 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18610 {
18611         if (ndr_flags & NDR_SCALARS) {
18612                 NDR_CHECK(ndr_push_align(ndr, 5));
18613                 {
18614                         uint32_t _flags_save_string = ndr->flags;
18615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18617                         ndr->flags = _flags_save_string;
18618                 }
18619                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18620         }
18621         if (ndr_flags & NDR_BUFFERS) {
18622                 {
18623                         uint32_t _flags_save_string = ndr->flags;
18624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18625                         if (r->name_array) {
18626                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->name_array));
18627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18628                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->name_array));
18629                         }
18630                         ndr->flags = _flags_save_string;
18631                 }
18632         }
18633         return NDR_ERR_SUCCESS;
18634 }
18635
18636 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18637 {
18638         uint32_t _ptr_name_array;
18639         TALLOC_CTX *_mem_save_name_array_0;
18640         if (ndr_flags & NDR_SCALARS) {
18641                 NDR_CHECK(ndr_pull_align(ndr, 5));
18642                 {
18643                         uint32_t _flags_save_string = ndr->flags;
18644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18646                         if (_ptr_name_array) {
18647                                 NDR_PULL_ALLOC(ndr, r->name_array);
18648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18649                         } else {
18650                                 r->name_array = NULL;
18651                         }
18652                         ndr->flags = _flags_save_string;
18653                 }
18654                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18655         }
18656         if (ndr_flags & NDR_BUFFERS) {
18657                 {
18658                         uint32_t _flags_save_string = ndr->flags;
18659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18660                         if (r->name_array) {
18661                                 uint32_t _relative_save_offset;
18662                                 _relative_save_offset = ndr->offset;
18663                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18664                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18665                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18666                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18667                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18668                                 if (ndr->offset > ndr->relative_highest_offset) {
18669                                         ndr->relative_highest_offset = ndr->offset;
18670                                 }
18671                                 ndr->offset = _relative_save_offset;
18672                         }
18673                         ndr->flags = _flags_save_string;
18674                 }
18675         }
18676         return NDR_ERR_SUCCESS;
18677 }
18678
18679 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18680 {
18681         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18682         ndr->depth++;
18683         ndr_print_ptr(ndr, "name_array", r->name_array);
18684         ndr->depth++;
18685         if (r->name_array) {
18686                 ndr_print_string(ndr, "name_array", r->name_array);
18687         }
18688         ndr->depth--;
18689         ndr->depth--;
18690 }
18691
18692 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18693 {
18694         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18695 }
18696
18697 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18698 {
18699         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18700         {
18701                 uint32_t _flags_save_UNION = ndr->flags;
18702                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18703                 if (ndr_flags & NDR_SCALARS) {
18704                         int level = ndr_push_get_switch_value(ndr, r);
18705                         NDR_CHECK(ndr_push_union_align(ndr, 5));
18706                         switch (level) {
18707                                 case 1: {
18708                                         NDR_CHECK(ndr_push_align(ndr, 5));
18709                                         NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18710                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18711                                 break; }
18712
18713                                 default: {
18714                                 break; }
18715
18716                         }
18717                 }
18718                 if (ndr_flags & NDR_BUFFERS) {
18719                         int level = ndr_push_get_switch_value(ndr, r);
18720                         NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18721                         switch (level) {
18722                                 case 1:
18723                                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18724                                 break;
18725
18726                                 default:
18727                                 break;
18728
18729                         }
18730                 }
18731                 ndr->flags = _flags_save_UNION;
18732         }
18733         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18734         return NDR_ERR_SUCCESS;
18735 }
18736
18737 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18738 {
18739         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18740         int level;
18741         {
18742                 uint32_t _flags_save_UNION = ndr->flags;
18743                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18744                 level = ndr_pull_get_switch_value(ndr, r);
18745                 if (ndr_flags & NDR_SCALARS) {
18746                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
18747                         switch (level) {
18748                                 case 1: {
18749                                         NDR_CHECK(ndr_pull_align(ndr, 5));
18750                                         NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18751                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18752                                 break; }
18753
18754                                 default: {
18755                                 break; }
18756
18757                         }
18758                 }
18759                 if (ndr_flags & NDR_BUFFERS) {
18760                         NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18761                         switch (level) {
18762                                 case 1:
18763                                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18764                                 break;
18765
18766                                 default:
18767                                 break;
18768
18769                         }
18770                 }
18771                 ndr->flags = _flags_save_UNION;
18772         }
18773         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18774         return NDR_ERR_SUCCESS;
18775 }
18776
18777 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18778 {
18779         int level;
18780         {
18781                 uint32_t _flags_save_UNION = ndr->flags;
18782                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_RELATIVE_REVERSE);
18783                 level = ndr_print_get_switch_value(ndr, r);
18784                 ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18785                 switch (level) {
18786                         case 1:
18787                                 ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18788                         break;
18789
18790                         default:
18791                         break;
18792
18793                 }
18794                 ndr->flags = _flags_save_UNION;
18795         }
18796 }
18797
18798 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18799 {
18800         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18801         return NDR_ERR_SUCCESS;
18802 }
18803
18804 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18805 {
18806         uint32_t v;
18807         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18808         *r = v;
18809         return NDR_ERR_SUCCESS;
18810 }
18811
18812 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18813 {
18814         ndr_print_uint32(ndr, name, r);
18815         ndr->depth++;
18816         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18817         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18818         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18819         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18820         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18821         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18822         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18827         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18828         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18829         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18830         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18831         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18832         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18836         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18837         ndr->depth--;
18838 }
18839
18840 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18841 {
18842         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18843         return NDR_ERR_SUCCESS;
18844 }
18845
18846 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18847 {
18848         uint16_t v;
18849         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18850         *r = v;
18851         return NDR_ERR_SUCCESS;
18852 }
18853
18854 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18855 {
18856         const char *val = NULL;
18857
18858         switch (r) {
18859                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18860                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18861                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18862                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18863                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18864                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18865                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18866                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18867                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18868                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18869                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18870                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18871                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18872                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18873                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18874                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18875                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18876                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18877                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18878                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18879                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18880                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18881                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18882                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18883         }
18884         ndr_print_enum(ndr, name, "ENUM", val, r);
18885 }
18886
18887 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18888 {
18889         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18890         return NDR_ERR_SUCCESS;
18891 }
18892
18893 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18894 {
18895         uint16_t v;
18896         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18897         *r = v;
18898         return NDR_ERR_SUCCESS;
18899 }
18900
18901 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18902 {
18903         const char *val = NULL;
18904
18905         switch (r) {
18906                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18907                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18908                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18909                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18910                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18911                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18912                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18913                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18914                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18915                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18916                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18917                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18918                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18919                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18920                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18921                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18922                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18923                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18924                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18925                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18926                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18927                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18928                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18929                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18930                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18931                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18932                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18933                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18934         }
18935         ndr_print_enum(ndr, name, "ENUM", val, r);
18936 }
18937
18938 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18939 {
18940         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18941         return NDR_ERR_SUCCESS;
18942 }
18943
18944 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18945 {
18946         uint16_t v;
18947         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18948         *r = v;
18949         return NDR_ERR_SUCCESS;
18950 }
18951
18952 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18953 {
18954         const char *val = NULL;
18955
18956         switch (r) {
18957                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18958                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18959         }
18960         ndr_print_enum(ndr, name, "ENUM", val, r);
18961 }
18962
18963 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18964 {
18965         if (ndr_flags & NDR_SCALARS) {
18966                 int level = ndr_push_get_switch_value(ndr, r);
18967                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18968                 switch (level) {
18969                         case PRINTER_NOTIFY_TYPE: {
18970                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18971                         break; }
18972
18973                         case JOB_NOTIFY_TYPE: {
18974                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18975                         break; }
18976
18977                         default: {
18978                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18979                         break; }
18980
18981                 }
18982         }
18983         if (ndr_flags & NDR_BUFFERS) {
18984                 int level = ndr_push_get_switch_value(ndr, r);
18985                 switch (level) {
18986                         case PRINTER_NOTIFY_TYPE:
18987                         break;
18988
18989                         case JOB_NOTIFY_TYPE:
18990                         break;
18991
18992                         default:
18993                         break;
18994
18995                 }
18996         }
18997         return NDR_ERR_SUCCESS;
18998 }
18999
19000 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
19001 {
19002         int level;
19003         level = ndr_pull_get_switch_value(ndr, r);
19004         if (ndr_flags & NDR_SCALARS) {
19005                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
19006                 switch (level) {
19007                         case PRINTER_NOTIFY_TYPE: {
19008                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
19009                         break; }
19010
19011                         case JOB_NOTIFY_TYPE: {
19012                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
19013                         break; }
19014
19015                         default: {
19016                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
19017                         break; }
19018
19019                 }
19020         }
19021         if (ndr_flags & NDR_BUFFERS) {
19022                 switch (level) {
19023                         case PRINTER_NOTIFY_TYPE:
19024                         break;
19025
19026                         case JOB_NOTIFY_TYPE:
19027                         break;
19028
19029                         default:
19030                         break;
19031
19032                 }
19033         }
19034         return NDR_ERR_SUCCESS;
19035 }
19036
19037 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
19038 {
19039         uint32_t cntr_fields_1;
19040         if (ndr_flags & NDR_SCALARS) {
19041                 NDR_CHECK(ndr_push_align(ndr, 5));
19042                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19043                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
19044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
19045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
19046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
19048                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19049         }
19050         if (ndr_flags & NDR_BUFFERS) {
19051                 if (r->fields) {
19052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19053                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
19054                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
19055                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
19056                         }
19057                 }
19058         }
19059         return NDR_ERR_SUCCESS;
19060 }
19061
19062 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
19063 {
19064         uint32_t _ptr_fields;
19065         uint32_t cntr_fields_1;
19066         TALLOC_CTX *_mem_save_fields_0;
19067         TALLOC_CTX *_mem_save_fields_1;
19068         if (ndr_flags & NDR_SCALARS) {
19069                 NDR_CHECK(ndr_pull_align(ndr, 5));
19070                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19071                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
19072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
19073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
19074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
19076                 if (_ptr_fields) {
19077                         NDR_PULL_ALLOC(ndr, r->fields);
19078                 } else {
19079                         r->fields = NULL;
19080                 }
19081                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19082         }
19083         if (ndr_flags & NDR_BUFFERS) {
19084                 if (r->fields) {
19085                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
19086                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
19087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
19088                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
19089                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
19090                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
19091                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
19092                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
19093                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
19094                         }
19095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
19096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
19097                 }
19098                 if (r->fields) {
19099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
19100                 }
19101         }
19102         return NDR_ERR_SUCCESS;
19103 }
19104
19105 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
19106 {
19107         uint32_t cntr_fields_1;
19108         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
19109         ndr->depth++;
19110         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19111         ndr_print_uint16(ndr, "u1", r->u1);
19112         ndr_print_uint32(ndr, "u2", r->u2);
19113         ndr_print_uint32(ndr, "u3", r->u3);
19114         ndr_print_uint32(ndr, "count", r->count);
19115         ndr_print_ptr(ndr, "fields", r->fields);
19116         ndr->depth++;
19117         if (r->fields) {
19118                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
19119                 ndr->depth++;
19120                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
19121                         char *idx_1=NULL;
19122                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
19123                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
19124                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
19125                                 free(idx_1);
19126                         }
19127                 }
19128                 ndr->depth--;
19129         }
19130         ndr->depth--;
19131         ndr->depth--;
19132 }
19133
19134 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19135 {
19136         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19137         return NDR_ERR_SUCCESS;
19138 }
19139
19140 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19141 {
19142         uint32_t v;
19143         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19144         *r = v;
19145         return NDR_ERR_SUCCESS;
19146 }
19147
19148 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19149 {
19150         ndr_print_uint32(ndr, name, r);
19151         ndr->depth++;
19152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
19153         ndr->depth--;
19154 }
19155
19156 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
19157 {
19158         uint32_t cntr_types_1;
19159         if (ndr_flags & NDR_SCALARS) {
19160                 NDR_CHECK(ndr_push_align(ndr, 5));
19161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19162                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
19163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
19165                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19166         }
19167         if (ndr_flags & NDR_BUFFERS) {
19168                 if (r->types) {
19169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19170                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19171                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
19172                         }
19173                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19174                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
19175                         }
19176                 }
19177         }
19178         return NDR_ERR_SUCCESS;
19179 }
19180
19181 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
19182 {
19183         uint32_t _ptr_types;
19184         uint32_t cntr_types_1;
19185         TALLOC_CTX *_mem_save_types_0;
19186         TALLOC_CTX *_mem_save_types_1;
19187         if (ndr_flags & NDR_SCALARS) {
19188                 NDR_CHECK(ndr_pull_align(ndr, 5));
19189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19190                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
19191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19192                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
19193                 if (_ptr_types) {
19194                         NDR_PULL_ALLOC(ndr, r->types);
19195                 } else {
19196                         r->types = NULL;
19197                 }
19198                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19199         }
19200         if (ndr_flags & NDR_BUFFERS) {
19201                 if (r->types) {
19202                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
19203                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
19204                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
19205                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
19206                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
19207                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
19208                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19209                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
19210                         }
19211                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
19212                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
19213                         }
19214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
19215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
19216                 }
19217                 if (r->types) {
19218                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
19219                 }
19220         }
19221         return NDR_ERR_SUCCESS;
19222 }
19223
19224 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
19225 {
19226         uint32_t cntr_types_1;
19227         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
19228         ndr->depth++;
19229         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19230         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
19231         ndr_print_uint32(ndr, "count", r->count);
19232         ndr_print_ptr(ndr, "types", r->types);
19233         ndr->depth++;
19234         if (r->types) {
19235                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
19236                 ndr->depth++;
19237                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
19238                         char *idx_1=NULL;
19239                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
19240                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
19241                                 free(idx_1);
19242                         }
19243                 }
19244                 ndr->depth--;
19245         }
19246         ndr->depth--;
19247         ndr->depth--;
19248 }
19249
19250 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
19251 {
19252         if (ndr_flags & NDR_SCALARS) {
19253                 NDR_CHECK(ndr_push_align(ndr, 5));
19254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
19256                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19257         }
19258         if (ndr_flags & NDR_BUFFERS) {
19259                 if (r->string) {
19260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
19261                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
19262                 }
19263         }
19264         return NDR_ERR_SUCCESS;
19265 }
19266
19267 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
19268 {
19269         uint32_t _ptr_string;
19270         TALLOC_CTX *_mem_save_string_0;
19271         if (ndr_flags & NDR_SCALARS) {
19272                 NDR_CHECK(ndr_pull_align(ndr, 5));
19273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
19275                 if (_ptr_string) {
19276                         NDR_PULL_ALLOC(ndr, r->string);
19277                 } else {
19278                         r->string = NULL;
19279                 }
19280                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19281         }
19282         if (ndr_flags & NDR_BUFFERS) {
19283                 if (r->string) {
19284                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
19285                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
19286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
19287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
19288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
19289                 }
19290                 if (r->string) {
19291                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
19292                 }
19293         }
19294         return NDR_ERR_SUCCESS;
19295 }
19296
19297 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
19298 {
19299         ndr_print_struct(ndr, name, "spoolss_NotifyString");
19300         ndr->depth++;
19301         ndr_print_uint32(ndr, "size", r->size);
19302         ndr_print_ptr(ndr, "string", r->string);
19303         ndr->depth++;
19304         if (r->string) {
19305                 ndr_print_string(ndr, "string", r->string);
19306         }
19307         ndr->depth--;
19308         ndr->depth--;
19309 }
19310
19311 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
19312 {
19313         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19314         return NDR_ERR_SUCCESS;
19315 }
19316
19317 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
19318 {
19319         uint32_t v;
19320         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19321         *r = v;
19322         return NDR_ERR_SUCCESS;
19323 }
19324
19325 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
19326 {
19327         const char *val = NULL;
19328
19329         switch (r) {
19330                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
19331                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
19332                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
19333                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
19334                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
19335         }
19336         ndr_print_enum(ndr, name, "ENUM", val, r);
19337 }
19338
19339 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
19340 {
19341         if (ndr_flags & NDR_SCALARS) {
19342                 int level = ndr_push_get_switch_value(ndr, r);
19343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19344                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19345                 switch (level) {
19346                         case 1: {
19347                                 uint32_t cntr_integer_0;
19348                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19349                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
19350                                 }
19351                         break; }
19352
19353                         case 2: {
19354                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19355                         break; }
19356
19357                         case 3: {
19358                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19359                         break; }
19360
19361                         case 4: {
19362                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19363                         break; }
19364
19365                         case 5: {
19366                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19367                         break; }
19368
19369                         default:
19370                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19371                 }
19372         }
19373         if (ndr_flags & NDR_BUFFERS) {
19374                 int level = ndr_push_get_switch_value(ndr, r);
19375                 switch (level) {
19376                         case 1:
19377                         break;
19378
19379                         case 2:
19380                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19381                         break;
19382
19383                         case 3:
19384                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19385                         break;
19386
19387                         case 4:
19388                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19389                         break;
19390
19391                         case 5:
19392                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19393                         break;
19394
19395                         default:
19396                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19397                 }
19398         }
19399         return NDR_ERR_SUCCESS;
19400 }
19401
19402 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
19403 {
19404         int level;
19405         uint32_t _level;
19406         level = ndr_pull_get_switch_value(ndr, r);
19407         if (ndr_flags & NDR_SCALARS) {
19408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19409                 if (_level != level) {
19410                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19411                 }
19412                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19413                 switch (level) {
19414                         case 1: {
19415                                 uint32_t cntr_integer_0;
19416                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
19417                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
19418                                 }
19419                         break; }
19420
19421                         case 2: {
19422                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
19423                         break; }
19424
19425                         case 3: {
19426                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
19427                         break; }
19428
19429                         case 4: {
19430                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
19431                         break; }
19432
19433                         case 5: {
19434                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
19435                         break; }
19436
19437                         default:
19438                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19439                 }
19440         }
19441         if (ndr_flags & NDR_BUFFERS) {
19442                 switch (level) {
19443                         case 1:
19444                         break;
19445
19446                         case 2:
19447                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
19448                         break;
19449
19450                         case 3:
19451                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
19452                         break;
19453
19454                         case 4:
19455                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
19456                         break;
19457
19458                         case 5:
19459                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
19460                         break;
19461
19462                         default:
19463                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19464                 }
19465         }
19466         return NDR_ERR_SUCCESS;
19467 }
19468
19469 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
19470 {
19471         int level;
19472         uint32_t cntr_integer_0;
19473         level = ndr_print_get_switch_value(ndr, r);
19474         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
19475         switch (level) {
19476                 case 1:
19477                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
19478                         ndr->depth++;
19479                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
19480                                 char *idx_0=NULL;
19481                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
19482                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
19483                                         free(idx_0);
19484                                 }
19485                         }
19486                         ndr->depth--;
19487                 break;
19488
19489                 case 2:
19490                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
19491                 break;
19492
19493                 case 3:
19494                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
19495                 break;
19496
19497                 case 4:
19498                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
19499                 break;
19500
19501                 case 5:
19502                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
19503                 break;
19504
19505                 default:
19506                         ndr_print_bad_level(ndr, name, level);
19507         }
19508 }
19509
19510 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
19511 {
19512         if (ndr_flags & NDR_SCALARS) {
19513                 NDR_CHECK(ndr_push_align(ndr, 5));
19514                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
19515                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
19516                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19517                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
19518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
19519                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
19520                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19521                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19522         }
19523         if (ndr_flags & NDR_BUFFERS) {
19524                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19525         }
19526         return NDR_ERR_SUCCESS;
19527 }
19528
19529 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
19530 {
19531         if (ndr_flags & NDR_SCALARS) {
19532                 NDR_CHECK(ndr_pull_align(ndr, 5));
19533                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
19534                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
19535                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
19536                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
19537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
19538                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
19539                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
19540                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19541         }
19542         if (ndr_flags & NDR_BUFFERS) {
19543                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
19544         }
19545         return NDR_ERR_SUCCESS;
19546 }
19547
19548 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
19549 {
19550         ndr_print_struct(ndr, name, "spoolss_Notify");
19551         ndr->depth++;
19552         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
19553         ndr_print_set_switch_value(ndr, &r->field, r->type);
19554         ndr_print_spoolss_Field(ndr, "field", &r->field);
19555         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
19556         ndr_print_uint32(ndr, "job_id", r->job_id);
19557         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
19558         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
19559         ndr->depth--;
19560 }
19561
19562 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
19563 {
19564         uint32_t cntr_notifies_0;
19565         if (ndr_flags & NDR_SCALARS) {
19566                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
19567                 NDR_CHECK(ndr_push_align(ndr, 5));
19568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
19569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
19571                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19572                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19573                 }
19574                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19575         }
19576         if (ndr_flags & NDR_BUFFERS) {
19577                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19578                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19579                 }
19580         }
19581         return NDR_ERR_SUCCESS;
19582 }
19583
19584 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19585 {
19586         uint32_t cntr_notifies_0;
19587         TALLOC_CTX *_mem_save_notifies_0;
19588         if (ndr_flags & NDR_SCALARS) {
19589                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19590                 NDR_CHECK(ndr_pull_align(ndr, 5));
19591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19594                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19595                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19596                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19597                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19598                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19599                 }
19600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19601                 if (r->notifies) {
19602                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19603                 }
19604                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19605         }
19606         if (ndr_flags & NDR_BUFFERS) {
19607                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19608                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19609                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19610                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19611                 }
19612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19613         }
19614         return NDR_ERR_SUCCESS;
19615 }
19616
19617 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19618 {
19619         uint32_t cntr_notifies_0;
19620         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19621         ndr->depth++;
19622         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19623         ndr_print_uint32(ndr, "flags", r->flags);
19624         ndr_print_uint32(ndr, "count", r->count);
19625         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19626         ndr->depth++;
19627         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19628                 char *idx_0=NULL;
19629                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19630                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19631                         free(idx_0);
19632                 }
19633         }
19634         ndr->depth--;
19635         ndr->depth--;
19636 }
19637
19638 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19639 {
19640         if (ndr_flags & NDR_SCALARS) {
19641                 int level = ndr_push_get_switch_value(ndr, r);
19642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19643                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19644                 switch (level) {
19645                         case 0: {
19646                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19647                         break; }
19648
19649                         default:
19650                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19651                 }
19652         }
19653         if (ndr_flags & NDR_BUFFERS) {
19654                 int level = ndr_push_get_switch_value(ndr, r);
19655                 switch (level) {
19656                         case 0:
19657                                 if (r->info0) {
19658                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19659                                 }
19660                         break;
19661
19662                         default:
19663                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19664                 }
19665         }
19666         return NDR_ERR_SUCCESS;
19667 }
19668
19669 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19670 {
19671         int level;
19672         uint32_t _level;
19673         TALLOC_CTX *_mem_save_info0_0;
19674         level = ndr_pull_get_switch_value(ndr, r);
19675         if (ndr_flags & NDR_SCALARS) {
19676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19677                 if (_level != level) {
19678                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19679                 }
19680                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19681                 switch (level) {
19682                         case 0: {
19683                                 uint32_t _ptr_info0;
19684                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19685                                 if (_ptr_info0) {
19686                                         NDR_PULL_ALLOC(ndr, r->info0);
19687                                 } else {
19688                                         r->info0 = NULL;
19689                                 }
19690                         break; }
19691
19692                         default:
19693                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19694                 }
19695         }
19696         if (ndr_flags & NDR_BUFFERS) {
19697                 switch (level) {
19698                         case 0:
19699                                 if (r->info0) {
19700                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19701                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19702                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19703                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19704                                 }
19705                         break;
19706
19707                         default:
19708                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19709                 }
19710         }
19711         return NDR_ERR_SUCCESS;
19712 }
19713
19714 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19715 {
19716         int level;
19717         level = ndr_print_get_switch_value(ndr, r);
19718         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19719         switch (level) {
19720                 case 0:
19721                         ndr_print_ptr(ndr, "info0", r->info0);
19722                         ndr->depth++;
19723                         if (r->info0) {
19724                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19725                         }
19726                         ndr->depth--;
19727                 break;
19728
19729                 default:
19730                         ndr_print_bad_level(ndr, name, level);
19731         }
19732 }
19733
19734 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19735 {
19736         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19737         return NDR_ERR_SUCCESS;
19738 }
19739
19740 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19741 {
19742         uint32_t v;
19743         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19744         *r = v;
19745         return NDR_ERR_SUCCESS;
19746 }
19747
19748 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19749 {
19750         ndr_print_uint32(ndr, name, r);
19751         ndr->depth++;
19752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19755         ndr->depth--;
19756 }
19757
19758 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19759 {
19760         if (ndr_flags & NDR_SCALARS) {
19761                 NDR_CHECK(ndr_push_align(ndr, 5));
19762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19766                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19767                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19768                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19769                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19770         }
19771         if (ndr_flags & NDR_BUFFERS) {
19772                 if (r->client) {
19773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19777                 }
19778                 if (r->user) {
19779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19783                 }
19784         }
19785         return NDR_ERR_SUCCESS;
19786 }
19787
19788 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19789 {
19790         uint32_t _ptr_client;
19791         TALLOC_CTX *_mem_save_client_0;
19792         uint32_t _ptr_user;
19793         TALLOC_CTX *_mem_save_user_0;
19794         if (ndr_flags & NDR_SCALARS) {
19795                 NDR_CHECK(ndr_pull_align(ndr, 5));
19796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19798                 if (_ptr_client) {
19799                         NDR_PULL_ALLOC(ndr, r->client);
19800                 } else {
19801                         r->client = NULL;
19802                 }
19803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19804                 if (_ptr_user) {
19805                         NDR_PULL_ALLOC(ndr, r->user);
19806                 } else {
19807                         r->user = NULL;
19808                 }
19809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19810                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19811                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19812                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19813                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19814         }
19815         if (ndr_flags & NDR_BUFFERS) {
19816                 if (r->client) {
19817                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19818                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19819                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19820                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19821                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19822                                 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));
19823                         }
19824                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19825                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19827                 }
19828                 if (r->user) {
19829                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19830                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19831                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19832                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19833                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19834                                 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));
19835                         }
19836                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19837                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19839                 }
19840         }
19841         return NDR_ERR_SUCCESS;
19842 }
19843
19844 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19845 {
19846         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19847         ndr->depth++;
19848         ndr_print_uint32(ndr, "size", r->size);
19849         ndr_print_ptr(ndr, "client", r->client);
19850         ndr->depth++;
19851         if (r->client) {
19852                 ndr_print_string(ndr, "client", r->client);
19853         }
19854         ndr->depth--;
19855         ndr_print_ptr(ndr, "user", r->user);
19856         ndr->depth++;
19857         if (r->user) {
19858                 ndr_print_string(ndr, "user", r->user);
19859         }
19860         ndr->depth--;
19861         ndr_print_uint32(ndr, "build", r->build);
19862         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19863         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19864         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19865         ndr->depth--;
19866 }
19867
19868 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19869 {
19870         if (ndr_flags & NDR_SCALARS) {
19871                 NDR_CHECK(ndr_push_align(ndr, 4));
19872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19873                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19874         }
19875         if (ndr_flags & NDR_BUFFERS) {
19876         }
19877         return NDR_ERR_SUCCESS;
19878 }
19879
19880 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19881 {
19882         if (ndr_flags & NDR_SCALARS) {
19883                 NDR_CHECK(ndr_pull_align(ndr, 4));
19884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19885                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19886         }
19887         if (ndr_flags & NDR_BUFFERS) {
19888         }
19889         return NDR_ERR_SUCCESS;
19890 }
19891
19892 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19893 {
19894         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19895         ndr->depth++;
19896         ndr_print_uint32(ndr, "not_used", r->not_used);
19897         ndr->depth--;
19898 }
19899
19900 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19901 {
19902         if (ndr_flags & NDR_SCALARS) {
19903                 NDR_CHECK(ndr_push_align(ndr, 5));
19904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19910                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19911                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19912                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19913                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19914                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19915         }
19916         if (ndr_flags & NDR_BUFFERS) {
19917                 if (r->client) {
19918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19919                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19920                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19921                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19922                 }
19923                 if (r->user) {
19924                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19927                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19928                 }
19929         }
19930         return NDR_ERR_SUCCESS;
19931 }
19932
19933 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19934 {
19935         uint32_t _ptr_client;
19936         TALLOC_CTX *_mem_save_client_0;
19937         uint32_t _ptr_user;
19938         TALLOC_CTX *_mem_save_user_0;
19939         if (ndr_flags & NDR_SCALARS) {
19940                 NDR_CHECK(ndr_pull_align(ndr, 5));
19941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19945                 if (_ptr_client) {
19946                         NDR_PULL_ALLOC(ndr, r->client);
19947                 } else {
19948                         r->client = NULL;
19949                 }
19950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19951                 if (_ptr_user) {
19952                         NDR_PULL_ALLOC(ndr, r->user);
19953                 } else {
19954                         r->user = NULL;
19955                 }
19956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19957                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19958                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19959                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19960                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19961                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19962         }
19963         if (ndr_flags & NDR_BUFFERS) {
19964                 if (r->client) {
19965                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19966                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19967                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19968                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19969                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19970                                 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));
19971                         }
19972                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19973                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19974                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19975                 }
19976                 if (r->user) {
19977                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19978                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19979                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19980                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19981                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19982                                 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));
19983                         }
19984                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19985                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19986                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19987                 }
19988         }
19989         return NDR_ERR_SUCCESS;
19990 }
19991
19992 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19993 {
19994         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19995         ndr->depth++;
19996         ndr_print_uint32(ndr, "size", r->size);
19997         ndr_print_uint32(ndr, "flags", r->flags);
19998         ndr_print_uint32(ndr, "size2", r->size2);
19999         ndr_print_ptr(ndr, "client", r->client);
20000         ndr->depth++;
20001         if (r->client) {
20002                 ndr_print_string(ndr, "client", r->client);
20003         }
20004         ndr->depth--;
20005         ndr_print_ptr(ndr, "user", r->user);
20006         ndr->depth++;
20007         if (r->user) {
20008                 ndr_print_string(ndr, "user", r->user);
20009         }
20010         ndr->depth--;
20011         ndr_print_uint32(ndr, "build", r->build);
20012         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
20013         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
20014         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
20015         ndr_print_udlong(ndr, "reserved", r->reserved);
20016         ndr->depth--;
20017 }
20018
20019 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
20020 {
20021         if (ndr_flags & NDR_SCALARS) {
20022                 int level = ndr_push_get_switch_value(ndr, r);
20023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
20024                 NDR_CHECK(ndr_push_union_align(ndr, 5));
20025                 switch (level) {
20026                         case 1: {
20027                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
20028                         break; }
20029
20030                         case 2: {
20031                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
20032                         break; }
20033
20034                         case 3: {
20035                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
20036                         break; }
20037
20038                         default:
20039                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20040                 }
20041         }
20042         if (ndr_flags & NDR_BUFFERS) {
20043                 int level = ndr_push_get_switch_value(ndr, r);
20044                 switch (level) {
20045                         case 1:
20046                                 if (r->level1) {
20047                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
20048                                 }
20049                         break;
20050
20051                         case 2:
20052                                 if (r->level2) {
20053                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
20054                                 }
20055                         break;
20056
20057                         case 3:
20058                                 if (r->level3) {
20059                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
20060                                 }
20061                         break;
20062
20063                         default:
20064                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20065                 }
20066         }
20067         return NDR_ERR_SUCCESS;
20068 }
20069
20070 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
20071 {
20072         int level;
20073         uint32_t _level;
20074         TALLOC_CTX *_mem_save_level1_0;
20075         TALLOC_CTX *_mem_save_level2_0;
20076         TALLOC_CTX *_mem_save_level3_0;
20077         level = ndr_pull_get_switch_value(ndr, r);
20078         if (ndr_flags & NDR_SCALARS) {
20079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
20080                 if (_level != level) {
20081                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
20082                 }
20083                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
20084                 switch (level) {
20085                         case 1: {
20086                                 uint32_t _ptr_level1;
20087                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
20088                                 if (_ptr_level1) {
20089                                         NDR_PULL_ALLOC(ndr, r->level1);
20090                                 } else {
20091                                         r->level1 = NULL;
20092                                 }
20093                         break; }
20094
20095                         case 2: {
20096                                 uint32_t _ptr_level2;
20097                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
20098                                 if (_ptr_level2) {
20099                                         NDR_PULL_ALLOC(ndr, r->level2);
20100                                 } else {
20101                                         r->level2 = NULL;
20102                                 }
20103                         break; }
20104
20105                         case 3: {
20106                                 uint32_t _ptr_level3;
20107                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
20108                                 if (_ptr_level3) {
20109                                         NDR_PULL_ALLOC(ndr, r->level3);
20110                                 } else {
20111                                         r->level3 = NULL;
20112                                 }
20113                         break; }
20114
20115                         default:
20116                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20117                 }
20118         }
20119         if (ndr_flags & NDR_BUFFERS) {
20120                 switch (level) {
20121                         case 1:
20122                                 if (r->level1) {
20123                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
20124                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
20125                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
20126                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
20127                                 }
20128                         break;
20129
20130                         case 2:
20131                                 if (r->level2) {
20132                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
20133                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
20134                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
20135                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
20136                                 }
20137                         break;
20138
20139                         case 3:
20140                                 if (r->level3) {
20141                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
20142                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
20143                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
20144                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
20145                                 }
20146                         break;
20147
20148                         default:
20149                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
20150                 }
20151         }
20152         return NDR_ERR_SUCCESS;
20153 }
20154
20155 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
20156 {
20157         int level;
20158         level = ndr_print_get_switch_value(ndr, r);
20159         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
20160         switch (level) {
20161                 case 1:
20162                         ndr_print_ptr(ndr, "level1", r->level1);
20163                         ndr->depth++;
20164                         if (r->level1) {
20165                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
20166                         }
20167                         ndr->depth--;
20168                 break;
20169
20170                 case 2:
20171                         ndr_print_ptr(ndr, "level2", r->level2);
20172                         ndr->depth++;
20173                         if (r->level2) {
20174                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
20175                         }
20176                         ndr->depth--;
20177                 break;
20178
20179                 case 3:
20180                         ndr_print_ptr(ndr, "level3", r->level3);
20181                         ndr->depth++;
20182                         if (r->level3) {
20183                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
20184                         }
20185                         ndr->depth--;
20186                 break;
20187
20188                 default:
20189                         ndr_print_bad_level(ndr, name, level);
20190         }
20191 }
20192
20193 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
20194 {
20195         if (ndr_flags & NDR_SCALARS) {
20196                 NDR_CHECK(ndr_push_align(ndr, 5));
20197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
20198                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
20199                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
20200                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
20201         }
20202         if (ndr_flags & NDR_BUFFERS) {
20203                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
20204         }
20205         return NDR_ERR_SUCCESS;
20206 }
20207
20208 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
20209 {
20210         if (ndr_flags & NDR_SCALARS) {
20211                 NDR_CHECK(ndr_pull_align(ndr, 5));
20212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
20213                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
20214                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
20215                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20216         }
20217         if (ndr_flags & NDR_BUFFERS) {
20218                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
20219         }
20220         return NDR_ERR_SUCCESS;
20221 }
20222
20223 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
20224 {
20225         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
20226         ndr->depth++;
20227         ndr_print_uint32(ndr, "level", r->level);
20228         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
20229         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
20230         ndr->depth--;
20231 }
20232
20233 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20234 {
20235         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20236         return NDR_ERR_SUCCESS;
20237 }
20238
20239 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20240 {
20241         uint32_t v;
20242         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20243         *r = v;
20244         return NDR_ERR_SUCCESS;
20245 }
20246
20247 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
20248 {
20249         ndr_print_uint32(ndr, name, r);
20250         ndr->depth++;
20251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
20252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
20253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
20254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
20255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
20256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
20257         ndr->depth--;
20258 }
20259
20260 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
20261 {
20262         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
20263         if (ndr_flags & NDR_SCALARS) {
20264                 NDR_CHECK(ndr_push_align(ndr, 5));
20265                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
20266                 {
20267                         uint32_t _flags_save_string = ndr->flags;
20268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
20270                         ndr->flags = _flags_save_string;
20271                 }
20272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
20273                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
20274                 {
20275                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
20277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
20278                         ndr->flags = _flags_save_DATA_BLOB;
20279                 }
20280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->data->length));
20281                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
20282         }
20283         if (ndr_flags & NDR_BUFFERS) {
20284                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
20285                 {
20286                         uint32_t _flags_save_string = ndr->flags;
20287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20288                         if (r->value_name) {
20289                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->value_name));
20290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
20291                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->value_name));
20292                         }
20293                         ndr->flags = _flags_save_string;
20294                 }
20295                 {
20296                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
20298                         if (r->data) {
20299                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->data));
20300                                 {
20301                                         struct ndr_push *_ndr_data;
20302                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data->length));
20303                                         NDR_CHECK(ndr_push_DATA_BLOB(_ndr_data, NDR_SCALARS, *r->data));
20304                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data->length));
20305                                 }
20306                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->data));
20307                         }
20308                         ndr->flags = _flags_save_DATA_BLOB;
20309                 }
20310         }
20311         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
20312         return NDR_ERR_SUCCESS;
20313 }
20314
20315 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
20316 {
20317         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
20318         uint32_t _ptr_value_name;
20319         TALLOC_CTX *_mem_save_value_name_0;
20320         uint32_t _ptr_data;
20321         TALLOC_CTX *_mem_save_data_0;
20322         if (ndr_flags & NDR_SCALARS) {
20323                 NDR_CHECK(ndr_pull_align(ndr, 5));
20324                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
20325                 {
20326                         uint32_t _flags_save_string = ndr->flags;
20327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20328                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
20329                         if (_ptr_value_name) {
20330                                 NDR_PULL_ALLOC(ndr, r->value_name);
20331                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
20332                         } else {
20333                                 r->value_name = NULL;
20334                         }
20335                         ndr->flags = _flags_save_string;
20336                 }
20337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
20338                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
20339                 {
20340                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
20342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
20343                         if (_ptr_data) {
20344                                 NDR_PULL_ALLOC(ndr, r->data);
20345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
20346                         } else {
20347                                 r->data = NULL;
20348                         }
20349                         ndr->flags = _flags_save_DATA_BLOB;
20350                 }
20351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
20352                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
20353         }
20354         if (ndr_flags & NDR_BUFFERS) {
20355                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
20356                 {
20357                         uint32_t _flags_save_string = ndr->flags;
20358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20359                         if (r->value_name) {
20360                                 uint32_t _relative_save_offset;
20361                                 _relative_save_offset = ndr->offset;
20362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
20363                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
20364                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
20365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
20366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
20367                                 if (ndr->offset > ndr->relative_highest_offset) {
20368                                         ndr->relative_highest_offset = ndr->offset;
20369                                 }
20370                                 ndr->offset = _relative_save_offset;
20371                         }
20372                         ndr->flags = _flags_save_string;
20373                 }
20374                 {
20375                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
20376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
20377                         if (r->data) {
20378                                 uint32_t _relative_save_offset;
20379                                 _relative_save_offset = ndr->offset;
20380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
20381                                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
20382                                 NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
20383                                 {
20384                                         struct ndr_pull *_ndr_data;
20385                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
20386                                         NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_data, NDR_SCALARS, r->data));
20387                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
20388                                 }
20389                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
20390                                 if (ndr->offset > ndr->relative_highest_offset) {
20391                                         ndr->relative_highest_offset = ndr->offset;
20392                                 }
20393                                 ndr->offset = _relative_save_offset;
20394                         }
20395                         ndr->flags = _flags_save_DATA_BLOB;
20396                 }
20397         }
20398         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
20399         return NDR_ERR_SUCCESS;
20400 }
20401
20402 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
20403 {
20404         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
20405         ndr->depth++;
20406         ndr_print_ptr(ndr, "value_name", r->value_name);
20407         ndr->depth++;
20408         if (r->value_name) {
20409                 ndr_print_string(ndr, "value_name", r->value_name);
20410         }
20411         ndr->depth--;
20412         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
20413         ndr_print_winreg_Type(ndr, "type", r->type);
20414         ndr_print_ptr(ndr, "data", r->data);
20415         ndr->depth++;
20416         if (r->data) {
20417                 ndr_print_DATA_BLOB(ndr, "data", *r->data);
20418         }
20419         ndr->depth--;
20420         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->data->length:r->data_length);
20421         ndr->depth--;
20422 }
20423
20424 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
20425 {
20426         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
20427 }
20428
20429 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
20430 {
20431         if (ndr_flags & NDR_SCALARS) {
20432                 int level = ndr_push_get_switch_value(ndr, r);
20433                 NDR_CHECK(ndr_push_union_align(ndr, 4));
20434                 switch (level) {
20435                         case 0: {
20436                         break; }
20437
20438                         case 1: {
20439                         break; }
20440
20441                         default: {
20442                                 {
20443                                         uint32_t _flags_save_string_array = ndr->flags;
20444                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20445                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
20446                                         ndr->flags = _flags_save_string_array;
20447                                 }
20448                         break; }
20449
20450                 }
20451         }
20452         if (ndr_flags & NDR_BUFFERS) {
20453                 int level = ndr_push_get_switch_value(ndr, r);
20454                 switch (level) {
20455                         case 0:
20456                         break;
20457
20458                         case 1:
20459                         break;
20460
20461                         default:
20462                         break;
20463
20464                 }
20465         }
20466         return NDR_ERR_SUCCESS;
20467 }
20468
20469 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
20470 {
20471         int level;
20472         level = ndr_pull_get_switch_value(ndr, r);
20473         if (ndr_flags & NDR_SCALARS) {
20474                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
20475                 switch (level) {
20476                         case 0: {
20477                         break; }
20478
20479                         case 1: {
20480                         break; }
20481
20482                         default: {
20483                                 {
20484                                         uint32_t _flags_save_string_array = ndr->flags;
20485                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20486                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
20487                                         ndr->flags = _flags_save_string_array;
20488                                 }
20489                         break; }
20490
20491                 }
20492         }
20493         if (ndr_flags & NDR_BUFFERS) {
20494                 switch (level) {
20495                         case 0:
20496                         break;
20497
20498                         case 1:
20499                         break;
20500
20501                         default:
20502                         break;
20503
20504                 }
20505         }
20506         return NDR_ERR_SUCCESS;
20507 }
20508
20509 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
20510 {
20511         int level;
20512         level = ndr_print_get_switch_value(ndr, r);
20513         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
20514         switch (level) {
20515                 case 0:
20516                 break;
20517
20518                 case 1:
20519                 break;
20520
20521                 default:
20522                         ndr_print_string_array(ndr, "string_array", r->string_array);
20523                 break;
20524
20525         }
20526 }
20527
20528 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20529 {
20530         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20531         return NDR_ERR_SUCCESS;
20532 }
20533
20534 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20535 {
20536         uint32_t v;
20537         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20538         *r = v;
20539         return NDR_ERR_SUCCESS;
20540 }
20541
20542 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20543 {
20544         ndr_print_uint32(ndr, name, r);
20545         ndr->depth++;
20546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
20547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
20548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
20549         ndr->depth--;
20550 }
20551
20552 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
20553 {
20554         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
20555         return NDR_ERR_SUCCESS;
20556 }
20557
20558 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
20559 {
20560         uint32_t v;
20561         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
20562         *r = v;
20563         return NDR_ERR_SUCCESS;
20564 }
20565
20566 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
20567 {
20568         const char *val = NULL;
20569
20570         switch (r) {
20571                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
20572                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
20573         }
20574         ndr_print_enum(ndr, name, "ENUM", val, r);
20575 }
20576
20577 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
20578 {
20579         if (ndr_flags & NDR_SCALARS) {
20580                 NDR_CHECK(ndr_push_align(ndr, 4));
20581                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
20583                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20586                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20589                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20590                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20591                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20596                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20597         }
20598         if (ndr_flags & NDR_BUFFERS) {
20599         }
20600         return NDR_ERR_SUCCESS;
20601 }
20602
20603 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20604 {
20605         if (ndr_flags & NDR_SCALARS) {
20606                 NDR_CHECK(ndr_pull_align(ndr, 4));
20607                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20609                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20612                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20613                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20615                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20616                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20617                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20618                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20623         }
20624         if (ndr_flags & NDR_BUFFERS) {
20625         }
20626         return NDR_ERR_SUCCESS;
20627 }
20628
20629 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20630 {
20631         ndr_print_struct(ndr, name, "spoolss_PortData1");
20632         ndr->depth++;
20633         ndr_print_string(ndr, "portname", r->portname);
20634         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20635         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20636         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20637         ndr_print_uint32(ndr, "reserved", r->reserved);
20638         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20639         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20640         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20641         ndr_print_string(ndr, "queue", r->queue);
20642         ndr_print_string(ndr, "ip_address", r->ip_address);
20643         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20644         ndr_print_string(ndr, "device_type", r->device_type);
20645         ndr_print_uint32(ndr, "port_number", r->port_number);
20646         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20647         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20648         ndr->depth--;
20649 }
20650
20651 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20652 {
20653         if (ndr_flags & NDR_SCALARS) {
20654                 NDR_CHECK(ndr_push_align(ndr, 4));
20655                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20657                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20660                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20661                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20663                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20664                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20669                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20670         }
20671         if (ndr_flags & NDR_BUFFERS) {
20672         }
20673         return NDR_ERR_SUCCESS;
20674 }
20675
20676 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20677 {
20678         if (ndr_flags & NDR_SCALARS) {
20679                 NDR_CHECK(ndr_pull_align(ndr, 4));
20680                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20682                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20685                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20686                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20688                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20689                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20690                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20694                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20695         }
20696         if (ndr_flags & NDR_BUFFERS) {
20697         }
20698         return NDR_ERR_SUCCESS;
20699 }
20700
20701 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20702 {
20703         ndr_print_struct(ndr, name, "spoolss_PortData2");
20704         ndr->depth++;
20705         ndr_print_string(ndr, "portname", r->portname);
20706         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20707         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20708         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20709         ndr_print_uint32(ndr, "reserved", r->reserved);
20710         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20711         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20712         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20713         ndr_print_string(ndr, "queue", r->queue);
20714         ndr_print_string(ndr, "device_type", r->device_type);
20715         ndr_print_uint32(ndr, "port_number", r->port_number);
20716         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20717         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20718         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20719         ndr->depth--;
20720 }
20721
20722 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20723 {
20724         if (ndr_flags & NDR_SCALARS) {
20725                 NDR_CHECK(ndr_push_align(ndr, 4));
20726                 {
20727                         uint32_t _flags_save_string = ndr->flags;
20728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20729                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20730                         ndr->flags = _flags_save_string;
20731                 }
20732                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20733         }
20734         if (ndr_flags & NDR_BUFFERS) {
20735         }
20736         return NDR_ERR_SUCCESS;
20737 }
20738
20739 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20740 {
20741         if (ndr_flags & NDR_SCALARS) {
20742                 NDR_CHECK(ndr_pull_align(ndr, 4));
20743                 {
20744                         uint32_t _flags_save_string = ndr->flags;
20745                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20746                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20747                         ndr->flags = _flags_save_string;
20748                 }
20749                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20750         }
20751         if (ndr_flags & NDR_BUFFERS) {
20752         }
20753         return NDR_ERR_SUCCESS;
20754 }
20755
20756 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20757 {
20758         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20759         ndr->depth++;
20760         ndr_print_string(ndr, "dll_name", r->dll_name);
20761         ndr->depth--;
20762 }
20763
20764 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20765 {
20766         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20767         return NDR_ERR_SUCCESS;
20768 }
20769
20770 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20771 {
20772         uint32_t v;
20773         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20774         *r = v;
20775         return NDR_ERR_SUCCESS;
20776 }
20777
20778 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20779 {
20780         ndr_print_uint32(ndr, name, r);
20781         ndr->depth++;
20782         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20783         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20784         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20785         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20786         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20787         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20788         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20789         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20790         ndr->depth--;
20791 }
20792
20793 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20794 {
20795         if (ndr_flags & NDR_SCALARS) {
20796                 NDR_CHECK(ndr_push_align(ndr, 8));
20797                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20798                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20800                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20801                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20802         }
20803         if (ndr_flags & NDR_BUFFERS) {
20804         }
20805         return NDR_ERR_SUCCESS;
20806 }
20807
20808 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20809 {
20810         if (ndr_flags & NDR_SCALARS) {
20811                 NDR_CHECK(ndr_pull_align(ndr, 8));
20812                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20813                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20814                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20815                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20816                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20817         }
20818         if (ndr_flags & NDR_BUFFERS) {
20819         }
20820         return NDR_ERR_SUCCESS;
20821 }
20822
20823 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20824 {
20825         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20826         ndr->depth++;
20827         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20828         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20829         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20830         ndr_print_string(ndr, "formname", r->formname);
20831         ndr->depth--;
20832 }
20833
20834 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20835 {
20836         if (flags & NDR_IN) {
20837                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20839                 if (r->in.server) {
20840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20841                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20842                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20844                 }
20845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20847                 if (r->in.buffer) {
20848                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20849                 }
20850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20851         }
20852         if (flags & NDR_OUT) {
20853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20854                 if (r->out.info) {
20855                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20856                 }
20857                 if (r->out.needed == NULL) {
20858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20859                 }
20860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20861                 if (r->out.count == NULL) {
20862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20863                 }
20864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20866         }
20867         return NDR_ERR_SUCCESS;
20868 }
20869
20870 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20871 {
20872         uint32_t _ptr_server;
20873         uint32_t _ptr_buffer;
20874         uint32_t _ptr_info;
20875         TALLOC_CTX *_mem_save_server_0;
20876         TALLOC_CTX *_mem_save_buffer_0;
20877         TALLOC_CTX *_mem_save_info_0;
20878         TALLOC_CTX *_mem_save_needed_0;
20879         TALLOC_CTX *_mem_save_count_0;
20880         if (flags & NDR_IN) {
20881                 ZERO_STRUCT(r->out);
20882
20883                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20885                 if (_ptr_server) {
20886                         NDR_PULL_ALLOC(ndr, r->in.server);
20887                 } else {
20888                         r->in.server = NULL;
20889                 }
20890                 if (r->in.server) {
20891                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20895                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20896                                 return 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));
20897                         }
20898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20901                 }
20902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20904                 if (_ptr_buffer) {
20905                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20906                 } else {
20907                         r->in.buffer = NULL;
20908                 }
20909                 if (r->in.buffer) {
20910                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20911                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20912                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20914                 }
20915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20916                 NDR_PULL_ALLOC(ndr, r->out.needed);
20917                 ZERO_STRUCTP(r->out.needed);
20918                 NDR_PULL_ALLOC(ndr, r->out.count);
20919                 ZERO_STRUCTP(r->out.count);
20920         }
20921         if (flags & NDR_OUT) {
20922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20923                 if (_ptr_info) {
20924                         NDR_PULL_ALLOC(ndr, r->out.info);
20925                 } else {
20926                         r->out.info = NULL;
20927                 }
20928                 if (r->out.info) {
20929                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20930                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20931                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20933                 }
20934                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20935                         NDR_PULL_ALLOC(ndr, r->out.needed);
20936                 }
20937                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20938                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20940                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20942                         NDR_PULL_ALLOC(ndr, r->out.count);
20943                 }
20944                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20945                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20949         }
20950         return NDR_ERR_SUCCESS;
20951 }
20952
20953 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20954 {
20955         uint32_t cntr_info_0;
20956         if (flags & NDR_IN) {
20957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20959         }
20960         if (flags & NDR_OUT) {
20961                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20962                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20963                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20964                 }
20965                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20966                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20967                 }
20968         }
20969         return NDR_ERR_SUCCESS;
20970 }
20971
20972 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20973 {
20974         uint32_t cntr_info_0;
20975         TALLOC_CTX *_mem_save_info_0;
20976         if (flags & NDR_IN) {
20977                 ZERO_STRUCT(r->out);
20978
20979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20981         }
20982         if (flags & NDR_OUT) {
20983                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20984                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20985                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20986                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20987                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20988                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20989                 }
20990                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20991                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20992                 }
20993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20994         }
20995         return NDR_ERR_SUCCESS;
20996 }
20997
20998 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20999 {
21000         uint32_t cntr_info_2;
21001         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
21002         ndr->depth++;
21003         if (flags & NDR_SET_VALUES) {
21004                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21005         }
21006         if (flags & NDR_IN) {
21007                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
21008                 ndr->depth++;
21009                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
21010                 ndr_print_ptr(ndr, "server", r->in.server);
21011                 ndr->depth++;
21012                 if (r->in.server) {
21013                         ndr_print_string(ndr, "server", r->in.server);
21014                 }
21015                 ndr->depth--;
21016                 ndr_print_uint32(ndr, "level", r->in.level);
21017                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21018                 ndr->depth++;
21019                 if (r->in.buffer) {
21020                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21021                 }
21022                 ndr->depth--;
21023                 ndr_print_uint32(ndr, "offered", r->in.offered);
21024                 ndr->depth--;
21025         }
21026         if (flags & NDR_OUT) {
21027                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
21028                 ndr->depth++;
21029                 ndr_print_ptr(ndr, "count", r->out.count);
21030                 ndr->depth++;
21031                 ndr_print_uint32(ndr, "count", *r->out.count);
21032                 ndr->depth--;
21033                 ndr_print_ptr(ndr, "info", r->out.info);
21034                 ndr->depth++;
21035                 ndr_print_ptr(ndr, "info", *r->out.info);
21036                 ndr->depth++;
21037                 if (*r->out.info) {
21038                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21039                         ndr->depth++;
21040                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21041                                 char *idx_2=NULL;
21042                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21043                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21044                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21045                                         free(idx_2);
21046                                 }
21047                         }
21048                         ndr->depth--;
21049                 }
21050                 ndr->depth--;
21051                 ndr->depth--;
21052                 ndr_print_ptr(ndr, "needed", r->out.needed);
21053                 ndr->depth++;
21054                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21055                 ndr->depth--;
21056                 ndr_print_WERROR(ndr, "result", r->out.result);
21057                 ndr->depth--;
21058         }
21059         ndr->depth--;
21060 }
21061
21062 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
21063 {
21064         if (flags & NDR_IN) {
21065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
21066                 if (r->in.printername) {
21067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
21070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21071                 }
21072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
21073                 if (r->in.datatype) {
21074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
21077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21078                 }
21079                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21080                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
21081         }
21082         if (flags & NDR_OUT) {
21083                 if (r->out.handle == NULL) {
21084                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21085                 }
21086                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21087                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21088         }
21089         return NDR_ERR_SUCCESS;
21090 }
21091
21092 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
21093 {
21094         uint32_t _ptr_printername;
21095         uint32_t _ptr_datatype;
21096         TALLOC_CTX *_mem_save_printername_0;
21097         TALLOC_CTX *_mem_save_datatype_0;
21098         TALLOC_CTX *_mem_save_handle_0;
21099         if (flags & NDR_IN) {
21100                 ZERO_STRUCT(r->out);
21101
21102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
21103                 if (_ptr_printername) {
21104                         NDR_PULL_ALLOC(ndr, r->in.printername);
21105                 } else {
21106                         r->in.printername = NULL;
21107                 }
21108                 if (r->in.printername) {
21109                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21110                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
21111                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
21112                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
21113                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
21114                                 return 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));
21115                         }
21116                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
21117                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
21118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
21119                 }
21120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
21121                 if (_ptr_datatype) {
21122                         NDR_PULL_ALLOC(ndr, r->in.datatype);
21123                 } else {
21124                         r->in.datatype = NULL;
21125                 }
21126                 if (r->in.datatype) {
21127                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
21128                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
21129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
21130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
21131                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
21132                                 return 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));
21133                         }
21134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
21135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
21136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
21137                 }
21138                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
21139                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
21140                 NDR_PULL_ALLOC(ndr, r->out.handle);
21141                 ZERO_STRUCTP(r->out.handle);
21142         }
21143         if (flags & NDR_OUT) {
21144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21145                         NDR_PULL_ALLOC(ndr, r->out.handle);
21146                 }
21147                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21148                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21149                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21150                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21151                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21152         }
21153         return NDR_ERR_SUCCESS;
21154 }
21155
21156 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
21157 {
21158         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
21159         ndr->depth++;
21160         if (flags & NDR_SET_VALUES) {
21161                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21162         }
21163         if (flags & NDR_IN) {
21164                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
21165                 ndr->depth++;
21166                 ndr_print_ptr(ndr, "printername", r->in.printername);
21167                 ndr->depth++;
21168                 if (r->in.printername) {
21169                         ndr_print_string(ndr, "printername", r->in.printername);
21170                 }
21171                 ndr->depth--;
21172                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
21173                 ndr->depth++;
21174                 if (r->in.datatype) {
21175                         ndr_print_string(ndr, "datatype", r->in.datatype);
21176                 }
21177                 ndr->depth--;
21178                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
21179                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
21180                 ndr->depth--;
21181         }
21182         if (flags & NDR_OUT) {
21183                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
21184                 ndr->depth++;
21185                 ndr_print_ptr(ndr, "handle", r->out.handle);
21186                 ndr->depth++;
21187                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21188                 ndr->depth--;
21189                 ndr_print_WERROR(ndr, "result", r->out.result);
21190                 ndr->depth--;
21191         }
21192         ndr->depth--;
21193 }
21194
21195 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
21196 {
21197         if (flags & NDR_IN) {
21198                 if (r->in.handle == NULL) {
21199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21200                 }
21201                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
21203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
21204                 if (r->in.ctr) {
21205                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
21206                 }
21207                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
21208         }
21209         if (flags & NDR_OUT) {
21210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21211         }
21212         return NDR_ERR_SUCCESS;
21213 }
21214
21215 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
21216 {
21217         uint32_t _ptr_ctr;
21218         TALLOC_CTX *_mem_save_handle_0;
21219         TALLOC_CTX *_mem_save_ctr_0;
21220         if (flags & NDR_IN) {
21221                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21222                         NDR_PULL_ALLOC(ndr, r->in.handle);
21223                 }
21224                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21225                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21226                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21227                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
21229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
21230                 if (_ptr_ctr) {
21231                         NDR_PULL_ALLOC(ndr, r->in.ctr);
21232                 } else {
21233                         r->in.ctr = NULL;
21234                 }
21235                 if (r->in.ctr) {
21236                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21237                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
21238                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
21239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
21240                 }
21241                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
21242         }
21243         if (flags & NDR_OUT) {
21244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21245         }
21246         return NDR_ERR_SUCCESS;
21247 }
21248
21249 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
21250 {
21251         ndr_print_struct(ndr, name, "spoolss_SetJob");
21252         ndr->depth++;
21253         if (flags & NDR_SET_VALUES) {
21254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21255         }
21256         if (flags & NDR_IN) {
21257                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
21258                 ndr->depth++;
21259                 ndr_print_ptr(ndr, "handle", r->in.handle);
21260                 ndr->depth++;
21261                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21262                 ndr->depth--;
21263                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21264                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
21265                 ndr->depth++;
21266                 if (r->in.ctr) {
21267                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
21268                 }
21269                 ndr->depth--;
21270                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
21271                 ndr->depth--;
21272         }
21273         if (flags & NDR_OUT) {
21274                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
21275                 ndr->depth++;
21276                 ndr_print_WERROR(ndr, "result", r->out.result);
21277                 ndr->depth--;
21278         }
21279         ndr->depth--;
21280 }
21281
21282 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
21283 {
21284         if (flags & NDR_IN) {
21285                 if (r->in.handle == NULL) {
21286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21287                 }
21288                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
21290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21292                 if (r->in.buffer) {
21293                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21294                 }
21295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21296         }
21297         if (flags & NDR_OUT) {
21298                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21299                 if (r->out.info) {
21300                         {
21301                                 struct ndr_push *_ndr_info;
21302                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21303                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21304                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21305                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21306                         }
21307                 }
21308                 if (r->out.needed == NULL) {
21309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21310                 }
21311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21312                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21313         }
21314         return NDR_ERR_SUCCESS;
21315 }
21316
21317 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
21318 {
21319         uint32_t _ptr_buffer;
21320         uint32_t _ptr_info;
21321         TALLOC_CTX *_mem_save_handle_0;
21322         TALLOC_CTX *_mem_save_buffer_0;
21323         TALLOC_CTX *_mem_save_info_0;
21324         TALLOC_CTX *_mem_save_needed_0;
21325         if (flags & NDR_IN) {
21326                 ZERO_STRUCT(r->out);
21327
21328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21329                         NDR_PULL_ALLOC(ndr, r->in.handle);
21330                 }
21331                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
21336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21338                 if (_ptr_buffer) {
21339                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21340                 } else {
21341                         r->in.buffer = NULL;
21342                 }
21343                 if (r->in.buffer) {
21344                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21345                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21346                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21348                 }
21349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21350                 NDR_PULL_ALLOC(ndr, r->out.needed);
21351                 ZERO_STRUCTP(r->out.needed);
21352         }
21353         if (flags & NDR_OUT) {
21354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21355                 if (_ptr_info) {
21356                         NDR_PULL_ALLOC(ndr, r->out.info);
21357                 } else {
21358                         r->out.info = NULL;
21359                 }
21360                 if (r->out.info) {
21361                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21362                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21363                         {
21364                                 struct ndr_pull *_ndr_info;
21365                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21366                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21367                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21368                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21369                         }
21370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21371                 }
21372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21373                         NDR_PULL_ALLOC(ndr, r->out.needed);
21374                 }
21375                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21376                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21380         }
21381         return NDR_ERR_SUCCESS;
21382 }
21383
21384 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
21385 {
21386         ndr_print_struct(ndr, name, "spoolss_GetJob");
21387         ndr->depth++;
21388         if (flags & NDR_SET_VALUES) {
21389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21390         }
21391         if (flags & NDR_IN) {
21392                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
21393                 ndr->depth++;
21394                 ndr_print_ptr(ndr, "handle", r->in.handle);
21395                 ndr->depth++;
21396                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21397                 ndr->depth--;
21398                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
21399                 ndr_print_uint32(ndr, "level", r->in.level);
21400                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21401                 ndr->depth++;
21402                 if (r->in.buffer) {
21403                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21404                 }
21405                 ndr->depth--;
21406                 ndr_print_uint32(ndr, "offered", r->in.offered);
21407                 ndr->depth--;
21408         }
21409         if (flags & NDR_OUT) {
21410                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
21411                 ndr->depth++;
21412                 ndr_print_ptr(ndr, "info", r->out.info);
21413                 ndr->depth++;
21414                 if (r->out.info) {
21415                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21416                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
21417                 }
21418                 ndr->depth--;
21419                 ndr_print_ptr(ndr, "needed", r->out.needed);
21420                 ndr->depth++;
21421                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21422                 ndr->depth--;
21423                 ndr_print_WERROR(ndr, "result", r->out.result);
21424                 ndr->depth--;
21425         }
21426         ndr->depth--;
21427 }
21428
21429 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
21430 {
21431         if (flags & NDR_IN) {
21432                 if (r->in.handle == NULL) {
21433                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21434                 }
21435                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
21437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
21438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21440                 if (r->in.buffer) {
21441                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21442                 }
21443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21444         }
21445         if (flags & NDR_OUT) {
21446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21447                 if (r->out.info) {
21448                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21449                 }
21450                 if (r->out.needed == NULL) {
21451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21452                 }
21453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21454                 if (r->out.count == NULL) {
21455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21456                 }
21457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21459         }
21460         return NDR_ERR_SUCCESS;
21461 }
21462
21463 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
21464 {
21465         uint32_t _ptr_buffer;
21466         uint32_t _ptr_info;
21467         TALLOC_CTX *_mem_save_handle_0;
21468         TALLOC_CTX *_mem_save_buffer_0;
21469         TALLOC_CTX *_mem_save_info_0;
21470         TALLOC_CTX *_mem_save_needed_0;
21471         TALLOC_CTX *_mem_save_count_0;
21472         if (flags & NDR_IN) {
21473                 ZERO_STRUCT(r->out);
21474
21475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21476                         NDR_PULL_ALLOC(ndr, r->in.handle);
21477                 }
21478                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21479                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21480                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
21483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
21484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21486                 if (_ptr_buffer) {
21487                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21488                 } else {
21489                         r->in.buffer = NULL;
21490                 }
21491                 if (r->in.buffer) {
21492                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21493                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21494                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21496                 }
21497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21498                 NDR_PULL_ALLOC(ndr, r->out.needed);
21499                 ZERO_STRUCTP(r->out.needed);
21500                 NDR_PULL_ALLOC(ndr, r->out.count);
21501                 ZERO_STRUCTP(r->out.count);
21502         }
21503         if (flags & NDR_OUT) {
21504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21505                 if (_ptr_info) {
21506                         NDR_PULL_ALLOC(ndr, r->out.info);
21507                 } else {
21508                         r->out.info = NULL;
21509                 }
21510                 if (r->out.info) {
21511                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21512                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21513                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21514                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21515                 }
21516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21517                         NDR_PULL_ALLOC(ndr, r->out.needed);
21518                 }
21519                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21520                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21523                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21524                         NDR_PULL_ALLOC(ndr, r->out.count);
21525                 }
21526                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21527                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21530                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21531         }
21532         return NDR_ERR_SUCCESS;
21533 }
21534
21535 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
21536 {
21537         uint32_t cntr_info_0;
21538         if (flags & NDR_IN) {
21539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21541         }
21542         if (flags & NDR_OUT) {
21543                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21544                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21545                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21546                 }
21547                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21548                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21549                 }
21550         }
21551         return NDR_ERR_SUCCESS;
21552 }
21553
21554 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
21555 {
21556         uint32_t cntr_info_0;
21557         TALLOC_CTX *_mem_save_info_0;
21558         if (flags & NDR_IN) {
21559                 ZERO_STRUCT(r->out);
21560
21561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21563         }
21564         if (flags & NDR_OUT) {
21565                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21566                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21568                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21569                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21570                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21571                 }
21572                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21573                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21574                 }
21575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21576         }
21577         return NDR_ERR_SUCCESS;
21578 }
21579
21580 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
21581 {
21582         uint32_t cntr_info_2;
21583         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
21584         ndr->depth++;
21585         if (flags & NDR_SET_VALUES) {
21586                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21587         }
21588         if (flags & NDR_IN) {
21589                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
21590                 ndr->depth++;
21591                 ndr_print_ptr(ndr, "handle", r->in.handle);
21592                 ndr->depth++;
21593                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21594                 ndr->depth--;
21595                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
21596                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
21597                 ndr_print_uint32(ndr, "level", r->in.level);
21598                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21599                 ndr->depth++;
21600                 if (r->in.buffer) {
21601                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21602                 }
21603                 ndr->depth--;
21604                 ndr_print_uint32(ndr, "offered", r->in.offered);
21605                 ndr->depth--;
21606         }
21607         if (flags & NDR_OUT) {
21608                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21609                 ndr->depth++;
21610                 ndr_print_ptr(ndr, "count", r->out.count);
21611                 ndr->depth++;
21612                 ndr_print_uint32(ndr, "count", *r->out.count);
21613                 ndr->depth--;
21614                 ndr_print_ptr(ndr, "info", r->out.info);
21615                 ndr->depth++;
21616                 ndr_print_ptr(ndr, "info", *r->out.info);
21617                 ndr->depth++;
21618                 if (*r->out.info) {
21619                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21620                         ndr->depth++;
21621                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21622                                 char *idx_2=NULL;
21623                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21624                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21625                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21626                                         free(idx_2);
21627                                 }
21628                         }
21629                         ndr->depth--;
21630                 }
21631                 ndr->depth--;
21632                 ndr->depth--;
21633                 ndr_print_ptr(ndr, "needed", r->out.needed);
21634                 ndr->depth++;
21635                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21636                 ndr->depth--;
21637                 ndr_print_WERROR(ndr, "result", r->out.result);
21638                 ndr->depth--;
21639         }
21640         ndr->depth--;
21641 }
21642
21643 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21644 {
21645         if (flags & NDR_IN) {
21646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21647                 if (r->in.server) {
21648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21652                 }
21653                 if (r->in.info_ctr == NULL) {
21654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21655                 }
21656                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21657                 if (r->in.devmode_ctr == NULL) {
21658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21659                 }
21660                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21661                 if (r->in.secdesc_ctr == NULL) {
21662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21663                 }
21664                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21665         }
21666         if (flags & NDR_OUT) {
21667                 if (r->out.handle == NULL) {
21668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21669                 }
21670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21671                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21672         }
21673         return NDR_ERR_SUCCESS;
21674 }
21675
21676 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21677 {
21678         uint32_t _ptr_server;
21679         TALLOC_CTX *_mem_save_server_0;
21680         TALLOC_CTX *_mem_save_info_ctr_0;
21681         TALLOC_CTX *_mem_save_devmode_ctr_0;
21682         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21683         TALLOC_CTX *_mem_save_handle_0;
21684         if (flags & NDR_IN) {
21685                 ZERO_STRUCT(r->out);
21686
21687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21688                 if (_ptr_server) {
21689                         NDR_PULL_ALLOC(ndr, r->in.server);
21690                 } else {
21691                         r->in.server = NULL;
21692                 }
21693                 if (r->in.server) {
21694                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21695                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21698                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21699                                 return 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));
21700                         }
21701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21704                 }
21705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21706                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21707                 }
21708                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21710                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21713                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21714                 }
21715                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21716                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21717                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21720                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21721                 }
21722                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21723                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21724                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21726                 NDR_PULL_ALLOC(ndr, r->out.handle);
21727                 ZERO_STRUCTP(r->out.handle);
21728         }
21729         if (flags & NDR_OUT) {
21730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21731                         NDR_PULL_ALLOC(ndr, r->out.handle);
21732                 }
21733                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21734                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21735                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21737                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21738         }
21739         return NDR_ERR_SUCCESS;
21740 }
21741
21742 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21743 {
21744         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21745         ndr->depth++;
21746         if (flags & NDR_SET_VALUES) {
21747                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21748         }
21749         if (flags & NDR_IN) {
21750                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21751                 ndr->depth++;
21752                 ndr_print_ptr(ndr, "server", r->in.server);
21753                 ndr->depth++;
21754                 if (r->in.server) {
21755                         ndr_print_string(ndr, "server", r->in.server);
21756                 }
21757                 ndr->depth--;
21758                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21759                 ndr->depth++;
21760                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21761                 ndr->depth--;
21762                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21763                 ndr->depth++;
21764                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21765                 ndr->depth--;
21766                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21767                 ndr->depth++;
21768                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21769                 ndr->depth--;
21770                 ndr->depth--;
21771         }
21772         if (flags & NDR_OUT) {
21773                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21774                 ndr->depth++;
21775                 ndr_print_ptr(ndr, "handle", r->out.handle);
21776                 ndr->depth++;
21777                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21778                 ndr->depth--;
21779                 ndr_print_WERROR(ndr, "result", r->out.result);
21780                 ndr->depth--;
21781         }
21782         ndr->depth--;
21783 }
21784
21785 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21786 {
21787         if (flags & NDR_IN) {
21788                 if (r->in.handle == NULL) {
21789                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21790                 }
21791                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21792         }
21793         if (flags & NDR_OUT) {
21794                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21795         }
21796         return NDR_ERR_SUCCESS;
21797 }
21798
21799 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21800 {
21801         TALLOC_CTX *_mem_save_handle_0;
21802         if (flags & NDR_IN) {
21803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21804                         NDR_PULL_ALLOC(ndr, r->in.handle);
21805                 }
21806                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21807                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21808                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21810         }
21811         if (flags & NDR_OUT) {
21812                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21813         }
21814         return NDR_ERR_SUCCESS;
21815 }
21816
21817 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21818 {
21819         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21820         ndr->depth++;
21821         if (flags & NDR_SET_VALUES) {
21822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21823         }
21824         if (flags & NDR_IN) {
21825                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21826                 ndr->depth++;
21827                 ndr_print_ptr(ndr, "handle", r->in.handle);
21828                 ndr->depth++;
21829                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21830                 ndr->depth--;
21831                 ndr->depth--;
21832         }
21833         if (flags & NDR_OUT) {
21834                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21835                 ndr->depth++;
21836                 ndr_print_WERROR(ndr, "result", r->out.result);
21837                 ndr->depth--;
21838         }
21839         ndr->depth--;
21840 }
21841
21842 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21843 {
21844         if (flags & NDR_IN) {
21845                 if (r->in.handle == NULL) {
21846                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21847                 }
21848                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21849                 if (r->in.info_ctr == NULL) {
21850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21851                 }
21852                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21853                 if (r->in.devmode_ctr == NULL) {
21854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21855                 }
21856                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21857                 if (r->in.secdesc_ctr == NULL) {
21858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21859                 }
21860                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21861                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21862         }
21863         if (flags & NDR_OUT) {
21864                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21865         }
21866         return NDR_ERR_SUCCESS;
21867 }
21868
21869 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21870 {
21871         TALLOC_CTX *_mem_save_handle_0;
21872         TALLOC_CTX *_mem_save_info_ctr_0;
21873         TALLOC_CTX *_mem_save_devmode_ctr_0;
21874         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21875         if (flags & NDR_IN) {
21876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21877                         NDR_PULL_ALLOC(ndr, r->in.handle);
21878                 }
21879                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21880                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21881                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21884                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21885                 }
21886                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21887                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21888                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21890                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21891                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21892                 }
21893                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21894                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21895                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21898                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21899                 }
21900                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21901                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21902                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21904                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21905         }
21906         if (flags & NDR_OUT) {
21907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21908         }
21909         return NDR_ERR_SUCCESS;
21910 }
21911
21912 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21913 {
21914         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21915         ndr->depth++;
21916         if (flags & NDR_SET_VALUES) {
21917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21918         }
21919         if (flags & NDR_IN) {
21920                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21921                 ndr->depth++;
21922                 ndr_print_ptr(ndr, "handle", r->in.handle);
21923                 ndr->depth++;
21924                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21925                 ndr->depth--;
21926                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21927                 ndr->depth++;
21928                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21929                 ndr->depth--;
21930                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21931                 ndr->depth++;
21932                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21933                 ndr->depth--;
21934                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21935                 ndr->depth++;
21936                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21937                 ndr->depth--;
21938                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21939                 ndr->depth--;
21940         }
21941         if (flags & NDR_OUT) {
21942                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21943                 ndr->depth++;
21944                 ndr_print_WERROR(ndr, "result", r->out.result);
21945                 ndr->depth--;
21946         }
21947         ndr->depth--;
21948 }
21949
21950 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21951 {
21952         if (flags & NDR_IN) {
21953                 if (r->in.handle == NULL) {
21954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21955                 }
21956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21959                 if (r->in.buffer) {
21960                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21961                 }
21962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21963         }
21964         if (flags & NDR_OUT) {
21965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21966                 if (r->out.info) {
21967                         {
21968                                 struct ndr_push *_ndr_info;
21969                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21970                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21971                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21972                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21973                         }
21974                 }
21975                 if (r->out.needed == NULL) {
21976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21977                 }
21978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21980         }
21981         return NDR_ERR_SUCCESS;
21982 }
21983
21984 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21985 {
21986         uint32_t _ptr_buffer;
21987         uint32_t _ptr_info;
21988         TALLOC_CTX *_mem_save_handle_0;
21989         TALLOC_CTX *_mem_save_buffer_0;
21990         TALLOC_CTX *_mem_save_info_0;
21991         TALLOC_CTX *_mem_save_needed_0;
21992         if (flags & NDR_IN) {
21993                 ZERO_STRUCT(r->out);
21994
21995                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21996                         NDR_PULL_ALLOC(ndr, r->in.handle);
21997                 }
21998                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21999                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22000                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22004                 if (_ptr_buffer) {
22005                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22006                 } else {
22007                         r->in.buffer = NULL;
22008                 }
22009                 if (r->in.buffer) {
22010                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22011                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22012                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22014                 }
22015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22016                 NDR_PULL_ALLOC(ndr, r->out.needed);
22017                 ZERO_STRUCTP(r->out.needed);
22018         }
22019         if (flags & NDR_OUT) {
22020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22021                 if (_ptr_info) {
22022                         NDR_PULL_ALLOC(ndr, r->out.info);
22023                 } else {
22024                         r->out.info = NULL;
22025                 }
22026                 if (r->out.info) {
22027                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22028                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22029                         {
22030                                 struct ndr_pull *_ndr_info;
22031                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22032                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22033                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22034                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22035                         }
22036                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22037                 }
22038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22039                         NDR_PULL_ALLOC(ndr, r->out.needed);
22040                 }
22041                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22042                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22046         }
22047         return NDR_ERR_SUCCESS;
22048 }
22049
22050 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
22051 {
22052         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
22053         ndr->depth++;
22054         if (flags & NDR_SET_VALUES) {
22055                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22056         }
22057         if (flags & NDR_IN) {
22058                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
22059                 ndr->depth++;
22060                 ndr_print_ptr(ndr, "handle", r->in.handle);
22061                 ndr->depth++;
22062                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22063                 ndr->depth--;
22064                 ndr_print_uint32(ndr, "level", r->in.level);
22065                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22066                 ndr->depth++;
22067                 if (r->in.buffer) {
22068                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22069                 }
22070                 ndr->depth--;
22071                 ndr_print_uint32(ndr, "offered", r->in.offered);
22072                 ndr->depth--;
22073         }
22074         if (flags & NDR_OUT) {
22075                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
22076                 ndr->depth++;
22077                 ndr_print_ptr(ndr, "info", r->out.info);
22078                 ndr->depth++;
22079                 if (r->out.info) {
22080                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22081                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
22082                 }
22083                 ndr->depth--;
22084                 ndr_print_ptr(ndr, "needed", r->out.needed);
22085                 ndr->depth++;
22086                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22087                 ndr->depth--;
22088                 ndr_print_WERROR(ndr, "result", r->out.result);
22089                 ndr->depth--;
22090         }
22091         ndr->depth--;
22092 }
22093
22094 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
22095 {
22096         if (flags & NDR_IN) {
22097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22098                 if (r->in.servername) {
22099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22103                 }
22104                 if (r->in.info_ctr == NULL) {
22105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22106                 }
22107                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22108         }
22109         if (flags & NDR_OUT) {
22110                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22111         }
22112         return NDR_ERR_SUCCESS;
22113 }
22114
22115 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
22116 {
22117         uint32_t _ptr_servername;
22118         TALLOC_CTX *_mem_save_servername_0;
22119         TALLOC_CTX *_mem_save_info_ctr_0;
22120         if (flags & NDR_IN) {
22121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22122                 if (_ptr_servername) {
22123                         NDR_PULL_ALLOC(ndr, r->in.servername);
22124                 } else {
22125                         r->in.servername = NULL;
22126                 }
22127                 if (r->in.servername) {
22128                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22129                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22130                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22131                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22132                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22133                                 return 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));
22134                         }
22135                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22138                 }
22139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22140                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
22141                 }
22142                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
22143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
22144                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
22145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
22146         }
22147         if (flags & NDR_OUT) {
22148                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22149         }
22150         return NDR_ERR_SUCCESS;
22151 }
22152
22153 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
22154 {
22155         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
22156         ndr->depth++;
22157         if (flags & NDR_SET_VALUES) {
22158                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22159         }
22160         if (flags & NDR_IN) {
22161                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
22162                 ndr->depth++;
22163                 ndr_print_ptr(ndr, "servername", r->in.servername);
22164                 ndr->depth++;
22165                 if (r->in.servername) {
22166                         ndr_print_string(ndr, "servername", r->in.servername);
22167                 }
22168                 ndr->depth--;
22169                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
22170                 ndr->depth++;
22171                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
22172                 ndr->depth--;
22173                 ndr->depth--;
22174         }
22175         if (flags & NDR_OUT) {
22176                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
22177                 ndr->depth++;
22178                 ndr_print_WERROR(ndr, "result", r->out.result);
22179                 ndr->depth--;
22180         }
22181         ndr->depth--;
22182 }
22183
22184 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
22185 {
22186         if (flags & NDR_IN) {
22187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22188                 if (r->in.server) {
22189                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22192                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22193                 }
22194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22195                 if (r->in.environment) {
22196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22200                 }
22201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22203                 if (r->in.buffer) {
22204                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22205                 }
22206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22207         }
22208         if (flags & NDR_OUT) {
22209                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22210                 if (r->out.info) {
22211                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22212                 }
22213                 if (r->out.needed == NULL) {
22214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22215                 }
22216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22217                 if (r->out.count == NULL) {
22218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22219                 }
22220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22221                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22222         }
22223         return NDR_ERR_SUCCESS;
22224 }
22225
22226 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
22227 {
22228         uint32_t _ptr_server;
22229         uint32_t _ptr_environment;
22230         uint32_t _ptr_buffer;
22231         uint32_t _ptr_info;
22232         TALLOC_CTX *_mem_save_server_0;
22233         TALLOC_CTX *_mem_save_environment_0;
22234         TALLOC_CTX *_mem_save_buffer_0;
22235         TALLOC_CTX *_mem_save_info_0;
22236         TALLOC_CTX *_mem_save_needed_0;
22237         TALLOC_CTX *_mem_save_count_0;
22238         if (flags & NDR_IN) {
22239                 ZERO_STRUCT(r->out);
22240
22241                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22242                 if (_ptr_server) {
22243                         NDR_PULL_ALLOC(ndr, r->in.server);
22244                 } else {
22245                         r->in.server = NULL;
22246                 }
22247                 if (r->in.server) {
22248                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22249                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22252                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22253                                 return 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));
22254                         }
22255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22258                 }
22259                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22260                 if (_ptr_environment) {
22261                         NDR_PULL_ALLOC(ndr, r->in.environment);
22262                 } else {
22263                         r->in.environment = NULL;
22264                 }
22265                 if (r->in.environment) {
22266                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22267                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22270                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22271                                 return 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));
22272                         }
22273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22276                 }
22277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22279                 if (_ptr_buffer) {
22280                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22281                 } else {
22282                         r->in.buffer = NULL;
22283                 }
22284                 if (r->in.buffer) {
22285                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22286                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22287                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22289                 }
22290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22291                 NDR_PULL_ALLOC(ndr, r->out.needed);
22292                 ZERO_STRUCTP(r->out.needed);
22293                 NDR_PULL_ALLOC(ndr, r->out.count);
22294                 ZERO_STRUCTP(r->out.count);
22295         }
22296         if (flags & NDR_OUT) {
22297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22298                 if (_ptr_info) {
22299                         NDR_PULL_ALLOC(ndr, r->out.info);
22300                 } else {
22301                         r->out.info = NULL;
22302                 }
22303                 if (r->out.info) {
22304                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22305                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22306                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22308                 }
22309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22310                         NDR_PULL_ALLOC(ndr, r->out.needed);
22311                 }
22312                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22313                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22316                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22317                         NDR_PULL_ALLOC(ndr, r->out.count);
22318                 }
22319                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22320                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22322                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22323                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22324         }
22325         return NDR_ERR_SUCCESS;
22326 }
22327
22328 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
22329 {
22330         uint32_t cntr_info_0;
22331         if (flags & NDR_IN) {
22332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22334         }
22335         if (flags & NDR_OUT) {
22336                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22337                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22338                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22339                 }
22340                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22341                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22342                 }
22343         }
22344         return NDR_ERR_SUCCESS;
22345 }
22346
22347 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
22348 {
22349         uint32_t cntr_info_0;
22350         TALLOC_CTX *_mem_save_info_0;
22351         if (flags & NDR_IN) {
22352                 ZERO_STRUCT(r->out);
22353
22354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22356         }
22357         if (flags & NDR_OUT) {
22358                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22359                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22360                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22361                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22362                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22363                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22364                 }
22365                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22366                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22367                 }
22368                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22369         }
22370         return NDR_ERR_SUCCESS;
22371 }
22372
22373 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
22374 {
22375         uint32_t cntr_info_2;
22376         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
22377         ndr->depth++;
22378         if (flags & NDR_SET_VALUES) {
22379                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22380         }
22381         if (flags & NDR_IN) {
22382                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
22383                 ndr->depth++;
22384                 ndr_print_ptr(ndr, "server", r->in.server);
22385                 ndr->depth++;
22386                 if (r->in.server) {
22387                         ndr_print_string(ndr, "server", r->in.server);
22388                 }
22389                 ndr->depth--;
22390                 ndr_print_ptr(ndr, "environment", r->in.environment);
22391                 ndr->depth++;
22392                 if (r->in.environment) {
22393                         ndr_print_string(ndr, "environment", r->in.environment);
22394                 }
22395                 ndr->depth--;
22396                 ndr_print_uint32(ndr, "level", r->in.level);
22397                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22398                 ndr->depth++;
22399                 if (r->in.buffer) {
22400                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22401                 }
22402                 ndr->depth--;
22403                 ndr_print_uint32(ndr, "offered", r->in.offered);
22404                 ndr->depth--;
22405         }
22406         if (flags & NDR_OUT) {
22407                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
22408                 ndr->depth++;
22409                 ndr_print_ptr(ndr, "count", r->out.count);
22410                 ndr->depth++;
22411                 ndr_print_uint32(ndr, "count", *r->out.count);
22412                 ndr->depth--;
22413                 ndr_print_ptr(ndr, "info", r->out.info);
22414                 ndr->depth++;
22415                 ndr_print_ptr(ndr, "info", *r->out.info);
22416                 ndr->depth++;
22417                 if (*r->out.info) {
22418                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22419                         ndr->depth++;
22420                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22421                                 char *idx_2=NULL;
22422                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22423                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22424                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22425                                         free(idx_2);
22426                                 }
22427                         }
22428                         ndr->depth--;
22429                 }
22430                 ndr->depth--;
22431                 ndr->depth--;
22432                 ndr_print_ptr(ndr, "needed", r->out.needed);
22433                 ndr->depth++;
22434                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22435                 ndr->depth--;
22436                 ndr_print_WERROR(ndr, "result", r->out.result);
22437                 ndr->depth--;
22438         }
22439         ndr->depth--;
22440 }
22441
22442 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
22443 {
22444         if (flags & NDR_IN) {
22445                 if (r->in.handle == NULL) {
22446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22447                 }
22448                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
22450                 if (r->in.architecture) {
22451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22455                 }
22456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22458                 if (r->in.buffer) {
22459                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22460                 }
22461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22462         }
22463         if (flags & NDR_OUT) {
22464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22465                 if (r->out.info) {
22466                         {
22467                                 struct ndr_push *_ndr_info;
22468                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22469                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22471                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22472                         }
22473                 }
22474                 if (r->out.needed == NULL) {
22475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22476                 }
22477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22479         }
22480         return NDR_ERR_SUCCESS;
22481 }
22482
22483 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
22484 {
22485         uint32_t _ptr_architecture;
22486         uint32_t _ptr_buffer;
22487         uint32_t _ptr_info;
22488         TALLOC_CTX *_mem_save_handle_0;
22489         TALLOC_CTX *_mem_save_architecture_0;
22490         TALLOC_CTX *_mem_save_buffer_0;
22491         TALLOC_CTX *_mem_save_info_0;
22492         TALLOC_CTX *_mem_save_needed_0;
22493         if (flags & NDR_IN) {
22494                 ZERO_STRUCT(r->out);
22495
22496                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22497                         NDR_PULL_ALLOC(ndr, r->in.handle);
22498                 }
22499                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22500                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22501                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22502                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
22504                 if (_ptr_architecture) {
22505                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22506                 } else {
22507                         r->in.architecture = NULL;
22508                 }
22509                 if (r->in.architecture) {
22510                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22511                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22514                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22515                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
22516                         }
22517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22518                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22520                 }
22521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22523                 if (_ptr_buffer) {
22524                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22525                 } else {
22526                         r->in.buffer = NULL;
22527                 }
22528                 if (r->in.buffer) {
22529                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22531                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22533                 }
22534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22535                 NDR_PULL_ALLOC(ndr, r->out.needed);
22536                 ZERO_STRUCTP(r->out.needed);
22537         }
22538         if (flags & NDR_OUT) {
22539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22540                 if (_ptr_info) {
22541                         NDR_PULL_ALLOC(ndr, r->out.info);
22542                 } else {
22543                         r->out.info = NULL;
22544                 }
22545                 if (r->out.info) {
22546                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22547                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22548                         {
22549                                 struct ndr_pull *_ndr_info;
22550                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22551                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22552                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22553                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22554                         }
22555                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22556                 }
22557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22558                         NDR_PULL_ALLOC(ndr, r->out.needed);
22559                 }
22560                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22561                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22564                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22565         }
22566         return NDR_ERR_SUCCESS;
22567 }
22568
22569 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
22570 {
22571         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
22572         ndr->depth++;
22573         if (flags & NDR_SET_VALUES) {
22574                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22575         }
22576         if (flags & NDR_IN) {
22577                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
22578                 ndr->depth++;
22579                 ndr_print_ptr(ndr, "handle", r->in.handle);
22580                 ndr->depth++;
22581                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22582                 ndr->depth--;
22583                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22584                 ndr->depth++;
22585                 if (r->in.architecture) {
22586                         ndr_print_string(ndr, "architecture", r->in.architecture);
22587                 }
22588                 ndr->depth--;
22589                 ndr_print_uint32(ndr, "level", r->in.level);
22590                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22591                 ndr->depth++;
22592                 if (r->in.buffer) {
22593                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22594                 }
22595                 ndr->depth--;
22596                 ndr_print_uint32(ndr, "offered", r->in.offered);
22597                 ndr->depth--;
22598         }
22599         if (flags & NDR_OUT) {
22600                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22601                 ndr->depth++;
22602                 ndr_print_ptr(ndr, "info", r->out.info);
22603                 ndr->depth++;
22604                 if (r->out.info) {
22605                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22606                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22607                 }
22608                 ndr->depth--;
22609                 ndr_print_ptr(ndr, "needed", r->out.needed);
22610                 ndr->depth++;
22611                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22612                 ndr->depth--;
22613                 ndr_print_WERROR(ndr, "result", r->out.result);
22614                 ndr->depth--;
22615         }
22616         ndr->depth--;
22617 }
22618
22619 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22620 {
22621         if (flags & NDR_IN) {
22622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22623                 if (r->in.server) {
22624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22627                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22628                 }
22629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22630                 if (r->in.environment) {
22631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22634                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22635                 }
22636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22638                 if (r->in.buffer) {
22639                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22640                 }
22641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22642         }
22643         if (flags & NDR_OUT) {
22644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22645                 if (r->out.info) {
22646                         {
22647                                 struct ndr_push *_ndr_info;
22648                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22649                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22650                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22651                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22652                         }
22653                 }
22654                 if (r->out.needed == NULL) {
22655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22656                 }
22657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22659         }
22660         return NDR_ERR_SUCCESS;
22661 }
22662
22663 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22664 {
22665         uint32_t _ptr_server;
22666         uint32_t _ptr_environment;
22667         uint32_t _ptr_buffer;
22668         uint32_t _ptr_info;
22669         TALLOC_CTX *_mem_save_server_0;
22670         TALLOC_CTX *_mem_save_environment_0;
22671         TALLOC_CTX *_mem_save_buffer_0;
22672         TALLOC_CTX *_mem_save_info_0;
22673         TALLOC_CTX *_mem_save_needed_0;
22674         if (flags & NDR_IN) {
22675                 ZERO_STRUCT(r->out);
22676
22677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22678                 if (_ptr_server) {
22679                         NDR_PULL_ALLOC(ndr, r->in.server);
22680                 } else {
22681                         r->in.server = NULL;
22682                 }
22683                 if (r->in.server) {
22684                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22685                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22686                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22687                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22688                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22689                                 return 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));
22690                         }
22691                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22692                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22694                 }
22695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22696                 if (_ptr_environment) {
22697                         NDR_PULL_ALLOC(ndr, r->in.environment);
22698                 } else {
22699                         r->in.environment = NULL;
22700                 }
22701                 if (r->in.environment) {
22702                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22703                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22705                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22706                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22707                                 return 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));
22708                         }
22709                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22710                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22712                 }
22713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22715                 if (_ptr_buffer) {
22716                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22717                 } else {
22718                         r->in.buffer = NULL;
22719                 }
22720                 if (r->in.buffer) {
22721                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22722                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22723                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22725                 }
22726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22727                 NDR_PULL_ALLOC(ndr, r->out.needed);
22728                 ZERO_STRUCTP(r->out.needed);
22729         }
22730         if (flags & NDR_OUT) {
22731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22732                 if (_ptr_info) {
22733                         NDR_PULL_ALLOC(ndr, r->out.info);
22734                 } else {
22735                         r->out.info = NULL;
22736                 }
22737                 if (r->out.info) {
22738                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22739                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22740                         {
22741                                 struct ndr_pull *_ndr_info;
22742                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22743                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22744                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22745                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22746                         }
22747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22748                 }
22749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22750                         NDR_PULL_ALLOC(ndr, r->out.needed);
22751                 }
22752                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22753                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22757         }
22758         return NDR_ERR_SUCCESS;
22759 }
22760
22761 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22762 {
22763         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22764         ndr->depth++;
22765         if (flags & NDR_SET_VALUES) {
22766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22767         }
22768         if (flags & NDR_IN) {
22769                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22770                 ndr->depth++;
22771                 ndr_print_ptr(ndr, "server", r->in.server);
22772                 ndr->depth++;
22773                 if (r->in.server) {
22774                         ndr_print_string(ndr, "server", r->in.server);
22775                 }
22776                 ndr->depth--;
22777                 ndr_print_ptr(ndr, "environment", r->in.environment);
22778                 ndr->depth++;
22779                 if (r->in.environment) {
22780                         ndr_print_string(ndr, "environment", r->in.environment);
22781                 }
22782                 ndr->depth--;
22783                 ndr_print_uint32(ndr, "level", r->in.level);
22784                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22785                 ndr->depth++;
22786                 if (r->in.buffer) {
22787                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22788                 }
22789                 ndr->depth--;
22790                 ndr_print_uint32(ndr, "offered", r->in.offered);
22791                 ndr->depth--;
22792         }
22793         if (flags & NDR_OUT) {
22794                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22795                 ndr->depth++;
22796                 ndr_print_ptr(ndr, "info", r->out.info);
22797                 ndr->depth++;
22798                 if (r->out.info) {
22799                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22800                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22801                 }
22802                 ndr->depth--;
22803                 ndr_print_ptr(ndr, "needed", r->out.needed);
22804                 ndr->depth++;
22805                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22806                 ndr->depth--;
22807                 ndr_print_WERROR(ndr, "result", r->out.result);
22808                 ndr->depth--;
22809         }
22810         ndr->depth--;
22811 }
22812
22813 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22814 {
22815         if (flags & NDR_IN) {
22816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22817                 if (r->in.server) {
22818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22822                 }
22823                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22824                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22825                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22826                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22827                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22828                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22829                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22830                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22831         }
22832         if (flags & NDR_OUT) {
22833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22834         }
22835         return NDR_ERR_SUCCESS;
22836 }
22837
22838 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22839 {
22840         uint32_t _ptr_server;
22841         TALLOC_CTX *_mem_save_server_0;
22842         if (flags & NDR_IN) {
22843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22844                 if (_ptr_server) {
22845                         NDR_PULL_ALLOC(ndr, r->in.server);
22846                 } else {
22847                         r->in.server = NULL;
22848                 }
22849                 if (r->in.server) {
22850                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22851                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22854                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22855                                 return 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));
22856                         }
22857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22860                 }
22861                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22862                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22863                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22864                         return 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));
22865                 }
22866                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22867                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22868                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22869                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22870                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22871                         return 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));
22872                 }
22873                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22874                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22875         }
22876         if (flags & NDR_OUT) {
22877                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22878         }
22879         return NDR_ERR_SUCCESS;
22880 }
22881
22882 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22883 {
22884         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22885         ndr->depth++;
22886         if (flags & NDR_SET_VALUES) {
22887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22888         }
22889         if (flags & NDR_IN) {
22890                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22891                 ndr->depth++;
22892                 ndr_print_ptr(ndr, "server", r->in.server);
22893                 ndr->depth++;
22894                 if (r->in.server) {
22895                         ndr_print_string(ndr, "server", r->in.server);
22896                 }
22897                 ndr->depth--;
22898                 ndr_print_string(ndr, "architecture", r->in.architecture);
22899                 ndr_print_string(ndr, "driver", r->in.driver);
22900                 ndr->depth--;
22901         }
22902         if (flags & NDR_OUT) {
22903                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22904                 ndr->depth++;
22905                 ndr_print_WERROR(ndr, "result", r->out.result);
22906                 ndr->depth--;
22907         }
22908         ndr->depth--;
22909 }
22910
22911 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22912 {
22913         if (flags & NDR_IN) {
22914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22915                 if (r->in.server) {
22916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22919                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22920                 }
22921                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22922                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22923                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22924                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22925                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22926                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22927                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22928                 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));
22929                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22930                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22931                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22932                 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));
22933         }
22934         if (flags & NDR_OUT) {
22935                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22936         }
22937         return NDR_ERR_SUCCESS;
22938 }
22939
22940 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22941 {
22942         uint32_t _ptr_server;
22943         TALLOC_CTX *_mem_save_server_0;
22944         if (flags & NDR_IN) {
22945                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22946                 if (_ptr_server) {
22947                         NDR_PULL_ALLOC(ndr, r->in.server);
22948                 } else {
22949                         r->in.server = NULL;
22950                 }
22951                 if (r->in.server) {
22952                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22953                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22956                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22957                                 return 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));
22958                         }
22959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22962                 }
22963                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22964                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22965                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22966                         return 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));
22967                 }
22968                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22969                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22970                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22971                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22972                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22973                         return 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));
22974                 }
22975                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22976                 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));
22977                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22978                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22979                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22980                         return 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));
22981                 }
22982                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22983                 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));
22984         }
22985         if (flags & NDR_OUT) {
22986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22987         }
22988         return NDR_ERR_SUCCESS;
22989 }
22990
22991 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22992 {
22993         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22994         ndr->depth++;
22995         if (flags & NDR_SET_VALUES) {
22996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22997         }
22998         if (flags & NDR_IN) {
22999                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
23000                 ndr->depth++;
23001                 ndr_print_ptr(ndr, "server", r->in.server);
23002                 ndr->depth++;
23003                 if (r->in.server) {
23004                         ndr_print_string(ndr, "server", r->in.server);
23005                 }
23006                 ndr->depth--;
23007                 ndr_print_string(ndr, "architecture", r->in.architecture);
23008                 ndr_print_string(ndr, "path_name", r->in.path_name);
23009                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23010                 ndr->depth--;
23011         }
23012         if (flags & NDR_OUT) {
23013                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
23014                 ndr->depth++;
23015                 ndr_print_WERROR(ndr, "result", r->out.result);
23016                 ndr->depth--;
23017         }
23018         ndr->depth--;
23019 }
23020
23021 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
23022 {
23023         if (flags & NDR_IN) {
23024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23025                 if (r->in.servername) {
23026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23028                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23029                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23030                 }
23031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
23032                 if (r->in.environment) {
23033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23036                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23037                 }
23038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23040                 if (r->in.buffer) {
23041                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23042                 }
23043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23044         }
23045         if (flags & NDR_OUT) {
23046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23047                 if (r->out.info) {
23048                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23049                 }
23050                 if (r->out.needed == NULL) {
23051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23052                 }
23053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23054                 if (r->out.count == NULL) {
23055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23056                 }
23057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23058                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23059         }
23060         return NDR_ERR_SUCCESS;
23061 }
23062
23063 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
23064 {
23065         uint32_t _ptr_servername;
23066         uint32_t _ptr_environment;
23067         uint32_t _ptr_buffer;
23068         uint32_t _ptr_info;
23069         TALLOC_CTX *_mem_save_servername_0;
23070         TALLOC_CTX *_mem_save_environment_0;
23071         TALLOC_CTX *_mem_save_buffer_0;
23072         TALLOC_CTX *_mem_save_info_0;
23073         TALLOC_CTX *_mem_save_needed_0;
23074         TALLOC_CTX *_mem_save_count_0;
23075         if (flags & NDR_IN) {
23076                 ZERO_STRUCT(r->out);
23077
23078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23079                 if (_ptr_servername) {
23080                         NDR_PULL_ALLOC(ndr, r->in.servername);
23081                 } else {
23082                         r->in.servername = NULL;
23083                 }
23084                 if (r->in.servername) {
23085                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23086                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23088                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23089                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23090                                 return 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));
23091                         }
23092                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23093                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23095                 }
23096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
23097                 if (_ptr_environment) {
23098                         NDR_PULL_ALLOC(ndr, r->in.environment);
23099                 } else {
23100                         r->in.environment = NULL;
23101                 }
23102                 if (r->in.environment) {
23103                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23107                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
23108                                 return 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));
23109                         }
23110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
23111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
23112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23113                 }
23114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23116                 if (_ptr_buffer) {
23117                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23118                 } else {
23119                         r->in.buffer = NULL;
23120                 }
23121                 if (r->in.buffer) {
23122                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23124                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23126                 }
23127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23128                 NDR_PULL_ALLOC(ndr, r->out.needed);
23129                 ZERO_STRUCTP(r->out.needed);
23130                 NDR_PULL_ALLOC(ndr, r->out.count);
23131                 ZERO_STRUCTP(r->out.count);
23132         }
23133         if (flags & NDR_OUT) {
23134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23135                 if (_ptr_info) {
23136                         NDR_PULL_ALLOC(ndr, r->out.info);
23137                 } else {
23138                         r->out.info = NULL;
23139                 }
23140                 if (r->out.info) {
23141                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23142                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23143                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23145                 }
23146                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23147                         NDR_PULL_ALLOC(ndr, r->out.needed);
23148                 }
23149                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23150                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23152                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23154                         NDR_PULL_ALLOC(ndr, r->out.count);
23155                 }
23156                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23157                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23160                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23161         }
23162         return NDR_ERR_SUCCESS;
23163 }
23164
23165 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
23166 {
23167         uint32_t cntr_info_0;
23168         if (flags & NDR_IN) {
23169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23171         }
23172         if (flags & NDR_OUT) {
23173                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23174                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23175                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23176                 }
23177                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23178                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23179                 }
23180         }
23181         return NDR_ERR_SUCCESS;
23182 }
23183
23184 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
23185 {
23186         uint32_t cntr_info_0;
23187         TALLOC_CTX *_mem_save_info_0;
23188         if (flags & NDR_IN) {
23189                 ZERO_STRUCT(r->out);
23190
23191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23193         }
23194         if (flags & NDR_OUT) {
23195                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23196                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23197                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23198                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23199                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23200                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23201                 }
23202                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23203                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23204                 }
23205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23206         }
23207         return NDR_ERR_SUCCESS;
23208 }
23209
23210 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
23211 {
23212         uint32_t cntr_info_2;
23213         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
23214         ndr->depth++;
23215         if (flags & NDR_SET_VALUES) {
23216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23217         }
23218         if (flags & NDR_IN) {
23219                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
23220                 ndr->depth++;
23221                 ndr_print_ptr(ndr, "servername", r->in.servername);
23222                 ndr->depth++;
23223                 if (r->in.servername) {
23224                         ndr_print_string(ndr, "servername", r->in.servername);
23225                 }
23226                 ndr->depth--;
23227                 ndr_print_ptr(ndr, "environment", r->in.environment);
23228                 ndr->depth++;
23229                 if (r->in.environment) {
23230                         ndr_print_string(ndr, "environment", r->in.environment);
23231                 }
23232                 ndr->depth--;
23233                 ndr_print_uint32(ndr, "level", r->in.level);
23234                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23235                 ndr->depth++;
23236                 if (r->in.buffer) {
23237                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23238                 }
23239                 ndr->depth--;
23240                 ndr_print_uint32(ndr, "offered", r->in.offered);
23241                 ndr->depth--;
23242         }
23243         if (flags & NDR_OUT) {
23244                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
23245                 ndr->depth++;
23246                 ndr_print_ptr(ndr, "count", r->out.count);
23247                 ndr->depth++;
23248                 ndr_print_uint32(ndr, "count", *r->out.count);
23249                 ndr->depth--;
23250                 ndr_print_ptr(ndr, "info", r->out.info);
23251                 ndr->depth++;
23252                 ndr_print_ptr(ndr, "info", *r->out.info);
23253                 ndr->depth++;
23254                 if (*r->out.info) {
23255                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23256                         ndr->depth++;
23257                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23258                                 char *idx_2=NULL;
23259                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23260                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23261                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23262                                         free(idx_2);
23263                                 }
23264                         }
23265                         ndr->depth--;
23266                 }
23267                 ndr->depth--;
23268                 ndr->depth--;
23269                 ndr_print_ptr(ndr, "needed", r->out.needed);
23270                 ndr->depth++;
23271                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23272                 ndr->depth--;
23273                 ndr_print_WERROR(ndr, "result", r->out.result);
23274                 ndr->depth--;
23275         }
23276         ndr->depth--;
23277 }
23278
23279 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23280 {
23281         if (flags & NDR_IN) {
23282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
23283                 if (r->in.server) {
23284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23287                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23288                 }
23289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
23290                 if (r->in.environment) {
23291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
23294                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23295                 }
23296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23298                 if (r->in.buffer) {
23299                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23300                 }
23301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23302         }
23303         if (flags & NDR_OUT) {
23304                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23305                 if (r->out.info) {
23306                         {
23307                                 struct ndr_push *_ndr_info;
23308                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23309                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23310                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23311                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23312                         }
23313                 }
23314                 if (r->out.needed == NULL) {
23315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23316                 }
23317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23319         }
23320         return NDR_ERR_SUCCESS;
23321 }
23322
23323 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
23324 {
23325         uint32_t _ptr_server;
23326         uint32_t _ptr_environment;
23327         uint32_t _ptr_buffer;
23328         uint32_t _ptr_info;
23329         TALLOC_CTX *_mem_save_server_0;
23330         TALLOC_CTX *_mem_save_environment_0;
23331         TALLOC_CTX *_mem_save_buffer_0;
23332         TALLOC_CTX *_mem_save_info_0;
23333         TALLOC_CTX *_mem_save_needed_0;
23334         if (flags & NDR_IN) {
23335                 ZERO_STRUCT(r->out);
23336
23337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
23338                 if (_ptr_server) {
23339                         NDR_PULL_ALLOC(ndr, r->in.server);
23340                 } else {
23341                         r->in.server = NULL;
23342                 }
23343                 if (r->in.server) {
23344                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
23345                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
23346                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
23347                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
23348                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
23349                                 return 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));
23350                         }
23351                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
23352                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
23353                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23354                 }
23355                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
23356                 if (_ptr_environment) {
23357                         NDR_PULL_ALLOC(ndr, r->in.environment);
23358                 } else {
23359                         r->in.environment = NULL;
23360                 }
23361                 if (r->in.environment) {
23362                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
23363                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
23364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
23365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
23366                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
23367                                 return 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));
23368                         }
23369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
23370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
23371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
23372                 }
23373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23375                 if (_ptr_buffer) {
23376                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23377                 } else {
23378                         r->in.buffer = NULL;
23379                 }
23380                 if (r->in.buffer) {
23381                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23383                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23385                 }
23386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23387                 NDR_PULL_ALLOC(ndr, r->out.needed);
23388                 ZERO_STRUCTP(r->out.needed);
23389         }
23390         if (flags & NDR_OUT) {
23391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23392                 if (_ptr_info) {
23393                         NDR_PULL_ALLOC(ndr, r->out.info);
23394                 } else {
23395                         r->out.info = NULL;
23396                 }
23397                 if (r->out.info) {
23398                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23399                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23400                         {
23401                                 struct ndr_pull *_ndr_info;
23402                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23403                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
23404                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
23405                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23406                         }
23407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23408                 }
23409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23410                         NDR_PULL_ALLOC(ndr, r->out.needed);
23411                 }
23412                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23413                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23416                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23417         }
23418         return NDR_ERR_SUCCESS;
23419 }
23420
23421 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
23422 {
23423         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
23424         ndr->depth++;
23425         if (flags & NDR_SET_VALUES) {
23426                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23427         }
23428         if (flags & NDR_IN) {
23429                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
23430                 ndr->depth++;
23431                 ndr_print_ptr(ndr, "server", r->in.server);
23432                 ndr->depth++;
23433                 if (r->in.server) {
23434                         ndr_print_string(ndr, "server", r->in.server);
23435                 }
23436                 ndr->depth--;
23437                 ndr_print_ptr(ndr, "environment", r->in.environment);
23438                 ndr->depth++;
23439                 if (r->in.environment) {
23440                         ndr_print_string(ndr, "environment", r->in.environment);
23441                 }
23442                 ndr->depth--;
23443                 ndr_print_uint32(ndr, "level", r->in.level);
23444                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23445                 ndr->depth++;
23446                 if (r->in.buffer) {
23447                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23448                 }
23449                 ndr->depth--;
23450                 ndr_print_uint32(ndr, "offered", r->in.offered);
23451                 ndr->depth--;
23452         }
23453         if (flags & NDR_OUT) {
23454                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
23455                 ndr->depth++;
23456                 ndr_print_ptr(ndr, "info", r->out.info);
23457                 ndr->depth++;
23458                 if (r->out.info) {
23459                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
23460                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
23461                 }
23462                 ndr->depth--;
23463                 ndr_print_ptr(ndr, "needed", r->out.needed);
23464                 ndr->depth++;
23465                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23466                 ndr->depth--;
23467                 ndr_print_WERROR(ndr, "result", r->out.result);
23468                 ndr->depth--;
23469         }
23470         ndr->depth--;
23471 }
23472
23473 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
23474 {
23475         if (flags & NDR_IN) {
23476                 if (r->in.handle == NULL) {
23477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23478                 }
23479                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23481                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23482                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23483         }
23484         if (flags & NDR_OUT) {
23485                 if (r->out.job_id == NULL) {
23486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23487                 }
23488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
23489                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23490         }
23491         return NDR_ERR_SUCCESS;
23492 }
23493
23494 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
23495 {
23496         TALLOC_CTX *_mem_save_handle_0;
23497         TALLOC_CTX *_mem_save_job_id_0;
23498         if (flags & NDR_IN) {
23499                 ZERO_STRUCT(r->out);
23500
23501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23502                         NDR_PULL_ALLOC(ndr, r->in.handle);
23503                 }
23504                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23505                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23506                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23509                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23510                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23511                 NDR_PULL_ALLOC(ndr, r->out.job_id);
23512                 ZERO_STRUCTP(r->out.job_id);
23513         }
23514         if (flags & NDR_OUT) {
23515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23516                         NDR_PULL_ALLOC(ndr, r->out.job_id);
23517                 }
23518                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
23519                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
23520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
23521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
23522                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23523         }
23524         return NDR_ERR_SUCCESS;
23525 }
23526
23527 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
23528 {
23529         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
23530         ndr->depth++;
23531         if (flags & NDR_SET_VALUES) {
23532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23533         }
23534         if (flags & NDR_IN) {
23535                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
23536                 ndr->depth++;
23537                 ndr_print_ptr(ndr, "handle", r->in.handle);
23538                 ndr->depth++;
23539                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23540                 ndr->depth--;
23541                 ndr_print_uint32(ndr, "level", r->in.level);
23542                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
23543                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
23544                 ndr->depth--;
23545         }
23546         if (flags & NDR_OUT) {
23547                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
23548                 ndr->depth++;
23549                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
23550                 ndr->depth++;
23551                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
23552                 ndr->depth--;
23553                 ndr_print_WERROR(ndr, "result", r->out.result);
23554                 ndr->depth--;
23555         }
23556         ndr->depth--;
23557 }
23558
23559 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
23560 {
23561         if (flags & NDR_IN) {
23562                 if (r->in.handle == NULL) {
23563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23564                 }
23565                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23566         }
23567         if (flags & NDR_OUT) {
23568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23569         }
23570         return NDR_ERR_SUCCESS;
23571 }
23572
23573 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
23574 {
23575         TALLOC_CTX *_mem_save_handle_0;
23576         if (flags & NDR_IN) {
23577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23578                         NDR_PULL_ALLOC(ndr, r->in.handle);
23579                 }
23580                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23581                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23582                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23584         }
23585         if (flags & NDR_OUT) {
23586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23587         }
23588         return NDR_ERR_SUCCESS;
23589 }
23590
23591 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
23592 {
23593         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
23594         ndr->depth++;
23595         if (flags & NDR_SET_VALUES) {
23596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23597         }
23598         if (flags & NDR_IN) {
23599                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23600                 ndr->depth++;
23601                 ndr_print_ptr(ndr, "handle", r->in.handle);
23602                 ndr->depth++;
23603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23604                 ndr->depth--;
23605                 ndr->depth--;
23606         }
23607         if (flags & NDR_OUT) {
23608                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23609                 ndr->depth++;
23610                 ndr_print_WERROR(ndr, "result", r->out.result);
23611                 ndr->depth--;
23612         }
23613         ndr->depth--;
23614 }
23615
23616 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23617 {
23618         if (flags & NDR_IN) {
23619                 if (r->in.handle == NULL) {
23620                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23621                 }
23622                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23623                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23625         }
23626         if (flags & NDR_OUT) {
23627                 if (r->out.num_written == NULL) {
23628                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23629                 }
23630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23631                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23632         }
23633         return NDR_ERR_SUCCESS;
23634 }
23635
23636 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23637 {
23638         TALLOC_CTX *_mem_save_handle_0;
23639         TALLOC_CTX *_mem_save_num_written_0;
23640         if (flags & NDR_IN) {
23641                 ZERO_STRUCT(r->out);
23642
23643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23644                         NDR_PULL_ALLOC(ndr, r->in.handle);
23645                 }
23646                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23648                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23650                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23652                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23653                 ZERO_STRUCTP(r->out.num_written);
23654         }
23655         if (flags & NDR_OUT) {
23656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23657                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23658                 }
23659                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23660                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23664         }
23665         return NDR_ERR_SUCCESS;
23666 }
23667
23668 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23669 {
23670         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23671         ndr->depth++;
23672         if (flags & NDR_SET_VALUES) {
23673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23674         }
23675         if (flags & NDR_IN) {
23676                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23677                 ndr->depth++;
23678                 ndr_print_ptr(ndr, "handle", r->in.handle);
23679                 ndr->depth++;
23680                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23681                 ndr->depth--;
23682                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23683                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23684                 ndr->depth--;
23685         }
23686         if (flags & NDR_OUT) {
23687                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23688                 ndr->depth++;
23689                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23690                 ndr->depth++;
23691                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23692                 ndr->depth--;
23693                 ndr_print_WERROR(ndr, "result", r->out.result);
23694                 ndr->depth--;
23695         }
23696         ndr->depth--;
23697 }
23698
23699 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23700 {
23701         if (flags & NDR_IN) {
23702                 if (r->in.handle == NULL) {
23703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23704                 }
23705                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23706         }
23707         if (flags & NDR_OUT) {
23708                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23709         }
23710         return NDR_ERR_SUCCESS;
23711 }
23712
23713 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23714 {
23715         TALLOC_CTX *_mem_save_handle_0;
23716         if (flags & NDR_IN) {
23717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23718                         NDR_PULL_ALLOC(ndr, r->in.handle);
23719                 }
23720                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23722                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23724         }
23725         if (flags & NDR_OUT) {
23726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23727         }
23728         return NDR_ERR_SUCCESS;
23729 }
23730
23731 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23732 {
23733         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23734         ndr->depth++;
23735         if (flags & NDR_SET_VALUES) {
23736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23737         }
23738         if (flags & NDR_IN) {
23739                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23740                 ndr->depth++;
23741                 ndr_print_ptr(ndr, "handle", r->in.handle);
23742                 ndr->depth++;
23743                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23744                 ndr->depth--;
23745                 ndr->depth--;
23746         }
23747         if (flags & NDR_OUT) {
23748                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23749                 ndr->depth++;
23750                 ndr_print_WERROR(ndr, "result", r->out.result);
23751                 ndr->depth--;
23752         }
23753         ndr->depth--;
23754 }
23755
23756 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23757 {
23758         if (flags & NDR_IN) {
23759                 if (r->in.handle == NULL) {
23760                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23761                 }
23762                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23763         }
23764         if (flags & NDR_OUT) {
23765                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23766         }
23767         return NDR_ERR_SUCCESS;
23768 }
23769
23770 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23771 {
23772         TALLOC_CTX *_mem_save_handle_0;
23773         if (flags & NDR_IN) {
23774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23775                         NDR_PULL_ALLOC(ndr, r->in.handle);
23776                 }
23777                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23781         }
23782         if (flags & NDR_OUT) {
23783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23784         }
23785         return NDR_ERR_SUCCESS;
23786 }
23787
23788 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23789 {
23790         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23791         ndr->depth++;
23792         if (flags & NDR_SET_VALUES) {
23793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23794         }
23795         if (flags & NDR_IN) {
23796                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23797                 ndr->depth++;
23798                 ndr_print_ptr(ndr, "handle", r->in.handle);
23799                 ndr->depth++;
23800                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23801                 ndr->depth--;
23802                 ndr->depth--;
23803         }
23804         if (flags & NDR_OUT) {
23805                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23806                 ndr->depth++;
23807                 ndr_print_WERROR(ndr, "result", r->out.result);
23808                 ndr->depth--;
23809         }
23810         ndr->depth--;
23811 }
23812
23813 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23814 {
23815         if (flags & NDR_IN) {
23816                 if (r->in.handle == NULL) {
23817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23818                 }
23819                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23821         }
23822         if (flags & NDR_OUT) {
23823                 if (r->out.data == NULL) {
23824                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23825                 }
23826                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23827                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23828                 if (r->out._data_size == NULL) {
23829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23830                 }
23831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23833         }
23834         return NDR_ERR_SUCCESS;
23835 }
23836
23837 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23838 {
23839         TALLOC_CTX *_mem_save_handle_0;
23840         TALLOC_CTX *_mem_save__data_size_0;
23841         if (flags & NDR_IN) {
23842                 ZERO_STRUCT(r->out);
23843
23844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23845                         NDR_PULL_ALLOC(ndr, r->in.handle);
23846                 }
23847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23852                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23853                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23854                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23855                 ZERO_STRUCTP(r->out._data_size);
23856         }
23857         if (flags & NDR_OUT) {
23858                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23860                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23861                 }
23862                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23864                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23865                 }
23866                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23867                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23871                 if (r->out.data) {
23872                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23873                 }
23874         }
23875         return NDR_ERR_SUCCESS;
23876 }
23877
23878 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23879 {
23880         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23881         ndr->depth++;
23882         if (flags & NDR_SET_VALUES) {
23883                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23884         }
23885         if (flags & NDR_IN) {
23886                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23887                 ndr->depth++;
23888                 ndr_print_ptr(ndr, "handle", r->in.handle);
23889                 ndr->depth++;
23890                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23891                 ndr->depth--;
23892                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23893                 ndr->depth--;
23894         }
23895         if (flags & NDR_OUT) {
23896                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23897                 ndr->depth++;
23898                 ndr_print_ptr(ndr, "data", r->out.data);
23899                 ndr->depth++;
23900                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23901                 ndr->depth--;
23902                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23903                 ndr->depth++;
23904                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23905                 ndr->depth--;
23906                 ndr_print_WERROR(ndr, "result", r->out.result);
23907                 ndr->depth--;
23908         }
23909         ndr->depth--;
23910 }
23911
23912 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23913 {
23914         if (flags & NDR_IN) {
23915                 if (r->in.handle == NULL) {
23916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23917                 }
23918                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23919         }
23920         if (flags & NDR_OUT) {
23921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23922         }
23923         return NDR_ERR_SUCCESS;
23924 }
23925
23926 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23927 {
23928         TALLOC_CTX *_mem_save_handle_0;
23929         if (flags & NDR_IN) {
23930                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23931                         NDR_PULL_ALLOC(ndr, r->in.handle);
23932                 }
23933                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23934                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23935                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23936                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23937         }
23938         if (flags & NDR_OUT) {
23939                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23940         }
23941         return NDR_ERR_SUCCESS;
23942 }
23943
23944 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23945 {
23946         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23947         ndr->depth++;
23948         if (flags & NDR_SET_VALUES) {
23949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23950         }
23951         if (flags & NDR_IN) {
23952                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23953                 ndr->depth++;
23954                 ndr_print_ptr(ndr, "handle", r->in.handle);
23955                 ndr->depth++;
23956                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23957                 ndr->depth--;
23958                 ndr->depth--;
23959         }
23960         if (flags & NDR_OUT) {
23961                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23962                 ndr->depth++;
23963                 ndr_print_WERROR(ndr, "result", r->out.result);
23964                 ndr->depth--;
23965         }
23966         ndr->depth--;
23967 }
23968
23969 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23970 {
23971         if (flags & NDR_IN) {
23972                 if (r->in.handle == NULL) {
23973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23974                 }
23975                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23977                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23978                 if (r->in.buffer) {
23979                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23980                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23981                 }
23982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23983         }
23984         if (flags & NDR_OUT) {
23985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23986                 if (r->out.buffer) {
23987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23988                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23989                 }
23990                 if (r->out.needed == NULL) {
23991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23992                 }
23993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23995         }
23996         return NDR_ERR_SUCCESS;
23997 }
23998
23999 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
24000 {
24001         uint32_t _ptr_buffer;
24002         TALLOC_CTX *_mem_save_handle_0;
24003         TALLOC_CTX *_mem_save_buffer_0;
24004         TALLOC_CTX *_mem_save_needed_0;
24005         if (flags & NDR_IN) {
24006                 ZERO_STRUCT(r->out);
24007
24008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24009                         NDR_PULL_ALLOC(ndr, r->in.handle);
24010                 }
24011                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24013                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24017                 if (_ptr_buffer) {
24018                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24019                 } else {
24020                         r->in.buffer = NULL;
24021                 }
24022                 if (r->in.buffer) {
24023                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24024                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24025                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24026                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24027                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24029                 }
24030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24031                 NDR_PULL_ALLOC(ndr, r->out.needed);
24032                 ZERO_STRUCTP(r->out.needed);
24033                 if (r->in.buffer) {
24034                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
24035                 }
24036         }
24037         if (flags & NDR_OUT) {
24038                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24039                 if (_ptr_buffer) {
24040                         NDR_PULL_ALLOC(ndr, r->out.buffer);
24041                 } else {
24042                         r->out.buffer = NULL;
24043                 }
24044                 if (r->out.buffer) {
24045                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24046                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
24047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
24048                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
24049                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
24050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24051                 }
24052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24053                         NDR_PULL_ALLOC(ndr, r->out.needed);
24054                 }
24055                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24056                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24060                 if (r->out.buffer) {
24061                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
24062                 }
24063         }
24064         return NDR_ERR_SUCCESS;
24065 }
24066
24067 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
24068 {
24069         ndr_print_struct(ndr, name, "spoolss_AddJob");
24070         ndr->depth++;
24071         if (flags & NDR_SET_VALUES) {
24072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24073         }
24074         if (flags & NDR_IN) {
24075                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
24076                 ndr->depth++;
24077                 ndr_print_ptr(ndr, "handle", r->in.handle);
24078                 ndr->depth++;
24079                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24080                 ndr->depth--;
24081                 ndr_print_uint32(ndr, "level", r->in.level);
24082                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24083                 ndr->depth++;
24084                 if (r->in.buffer) {
24085                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
24086                 }
24087                 ndr->depth--;
24088                 ndr_print_uint32(ndr, "offered", r->in.offered);
24089                 ndr->depth--;
24090         }
24091         if (flags & NDR_OUT) {
24092                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
24093                 ndr->depth++;
24094                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
24095                 ndr->depth++;
24096                 if (r->out.buffer) {
24097                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
24098                 }
24099                 ndr->depth--;
24100                 ndr_print_ptr(ndr, "needed", r->out.needed);
24101                 ndr->depth++;
24102                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24103                 ndr->depth--;
24104                 ndr_print_WERROR(ndr, "result", r->out.result);
24105                 ndr->depth--;
24106         }
24107         ndr->depth--;
24108 }
24109
24110 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
24111 {
24112         if (flags & NDR_IN) {
24113                 if (r->in.handle == NULL) {
24114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24115                 }
24116                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
24118         }
24119         if (flags & NDR_OUT) {
24120                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24121         }
24122         return NDR_ERR_SUCCESS;
24123 }
24124
24125 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
24126 {
24127         TALLOC_CTX *_mem_save_handle_0;
24128         if (flags & NDR_IN) {
24129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24130                         NDR_PULL_ALLOC(ndr, r->in.handle);
24131                 }
24132                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24133                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24134                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24136                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
24137         }
24138         if (flags & NDR_OUT) {
24139                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24140         }
24141         return NDR_ERR_SUCCESS;
24142 }
24143
24144 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
24145 {
24146         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
24147         ndr->depth++;
24148         if (flags & NDR_SET_VALUES) {
24149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24150         }
24151         if (flags & NDR_IN) {
24152                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
24153                 ndr->depth++;
24154                 ndr_print_ptr(ndr, "handle", r->in.handle);
24155                 ndr->depth++;
24156                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24157                 ndr->depth--;
24158                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
24159                 ndr->depth--;
24160         }
24161         if (flags & NDR_OUT) {
24162                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
24163                 ndr->depth++;
24164                 ndr_print_WERROR(ndr, "result", r->out.result);
24165                 ndr->depth--;
24166         }
24167         ndr->depth--;
24168 }
24169
24170 static enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
24171 {
24172         if (flags & NDR_IN) {
24173                 if (r->in.handle == NULL) {
24174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24175                 }
24176                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24177                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24178                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24179                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24180                 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));
24181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24182         }
24183         if (flags & NDR_OUT) {
24184                 if (r->out.type == NULL) {
24185                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24186                 }
24187                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
24188                 if (r->out.data == NULL) {
24189                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24190                 }
24191                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
24192                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
24193                 if (r->out.needed == NULL) {
24194                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24195                 }
24196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24197                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24198         }
24199         return NDR_ERR_SUCCESS;
24200 }
24201
24202 static enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
24203 {
24204         TALLOC_CTX *_mem_save_handle_0;
24205         TALLOC_CTX *_mem_save_type_0;
24206         TALLOC_CTX *_mem_save_needed_0;
24207         if (flags & NDR_IN) {
24208                 ZERO_STRUCT(r->out);
24209
24210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24211                         NDR_PULL_ALLOC(ndr, r->in.handle);
24212                 }
24213                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24214                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24215                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24217                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24218                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24219                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24220                         return 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));
24221                 }
24222                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24223                 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));
24224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24225                 NDR_PULL_ALLOC(ndr, r->out.type);
24226                 ZERO_STRUCTP(r->out.type);
24227                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
24228                 memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
24229                 NDR_PULL_ALLOC(ndr, r->out.needed);
24230                 ZERO_STRUCTP(r->out.needed);
24231         }
24232         if (flags & NDR_OUT) {
24233                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24234                         NDR_PULL_ALLOC(ndr, r->out.type);
24235                 }
24236                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24237                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
24238                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
24239                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
24240                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
24241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24242                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
24243                 }
24244                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
24245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24246                         NDR_PULL_ALLOC(ndr, r->out.needed);
24247                 }
24248                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24249                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24253                 if (r->out.data) {
24254                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
24255                 }
24256         }
24257         return NDR_ERR_SUCCESS;
24258 }
24259
24260 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
24261 {
24262         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
24263         ndr->depth++;
24264         if (flags & NDR_SET_VALUES) {
24265                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24266         }
24267         if (flags & NDR_IN) {
24268                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
24269                 ndr->depth++;
24270                 ndr_print_ptr(ndr, "handle", r->in.handle);
24271                 ndr->depth++;
24272                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24273                 ndr->depth--;
24274                 ndr_print_string(ndr, "value_name", r->in.value_name);
24275                 ndr_print_uint32(ndr, "offered", r->in.offered);
24276                 ndr->depth--;
24277         }
24278         if (flags & NDR_OUT) {
24279                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
24280                 ndr->depth++;
24281                 ndr_print_ptr(ndr, "type", r->out.type);
24282                 ndr->depth++;
24283                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
24284                 ndr->depth--;
24285                 ndr_print_ptr(ndr, "data", r->out.data);
24286                 ndr->depth++;
24287                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
24288                 ndr->depth--;
24289                 ndr_print_ptr(ndr, "needed", r->out.needed);
24290                 ndr->depth++;
24291                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24292                 ndr->depth--;
24293                 ndr_print_WERROR(ndr, "result", r->out.result);
24294                 ndr->depth--;
24295         }
24296         ndr->depth--;
24297 }
24298
24299 static enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
24300 {
24301         if (flags & NDR_IN) {
24302                 if (r->in.handle == NULL) {
24303                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24304                 }
24305                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24306                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24307                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24308                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24309                 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));
24310                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24311                 if (r->in.data == NULL) {
24312                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24313                 }
24314                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
24315                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
24316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24317         }
24318         if (flags & NDR_OUT) {
24319                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24320         }
24321         return NDR_ERR_SUCCESS;
24322 }
24323
24324 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
24325 {
24326         TALLOC_CTX *_mem_save_handle_0;
24327         if (flags & NDR_IN) {
24328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24329                         NDR_PULL_ALLOC(ndr, r->in.handle);
24330                 }
24331                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24335                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24336                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24337                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24338                         return 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));
24339                 }
24340                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24341                 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));
24342                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24343                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
24344                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24345                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
24346                 }
24347                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
24348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24349                 if (r->in.data) {
24350                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
24351                 }
24352         }
24353         if (flags & NDR_OUT) {
24354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24355         }
24356         return NDR_ERR_SUCCESS;
24357 }
24358
24359 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
24360 {
24361         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
24362         ndr->depth++;
24363         if (flags & NDR_SET_VALUES) {
24364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24365         }
24366         if (flags & NDR_IN) {
24367                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
24368                 ndr->depth++;
24369                 ndr_print_ptr(ndr, "handle", r->in.handle);
24370                 ndr->depth++;
24371                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24372                 ndr->depth--;
24373                 ndr_print_string(ndr, "value_name", r->in.value_name);
24374                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24375                 ndr_print_ptr(ndr, "data", r->in.data);
24376                 ndr->depth++;
24377                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
24378                 ndr->depth--;
24379                 ndr_print_uint32(ndr, "offered", r->in.offered);
24380                 ndr->depth--;
24381         }
24382         if (flags & NDR_OUT) {
24383                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
24384                 ndr->depth++;
24385                 ndr_print_WERROR(ndr, "result", r->out.result);
24386                 ndr->depth--;
24387         }
24388         ndr->depth--;
24389 }
24390
24391 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
24392 {
24393         if (flags & NDR_IN) {
24394         }
24395         if (flags & NDR_OUT) {
24396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24397         }
24398         return NDR_ERR_SUCCESS;
24399 }
24400
24401 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
24402 {
24403         if (flags & NDR_IN) {
24404         }
24405         if (flags & NDR_OUT) {
24406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24407         }
24408         return NDR_ERR_SUCCESS;
24409 }
24410
24411 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
24412 {
24413         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
24414         ndr->depth++;
24415         if (flags & NDR_SET_VALUES) {
24416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24417         }
24418         if (flags & NDR_IN) {
24419                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
24420                 ndr->depth++;
24421                 ndr->depth--;
24422         }
24423         if (flags & NDR_OUT) {
24424                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
24425                 ndr->depth++;
24426                 ndr_print_WERROR(ndr, "result", r->out.result);
24427                 ndr->depth--;
24428         }
24429         ndr->depth--;
24430 }
24431
24432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
24433 {
24434         if (flags & NDR_IN) {
24435                 if (r->in.handle == NULL) {
24436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24437                 }
24438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24439         }
24440         if (flags & NDR_OUT) {
24441                 if (r->out.handle == NULL) {
24442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24443                 }
24444                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24446         }
24447         return NDR_ERR_SUCCESS;
24448 }
24449
24450 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
24451 {
24452         TALLOC_CTX *_mem_save_handle_0;
24453         if (flags & NDR_IN) {
24454                 ZERO_STRUCT(r->out);
24455
24456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24457                         NDR_PULL_ALLOC(ndr, r->in.handle);
24458                 }
24459                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24460                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24461                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24463                 NDR_PULL_ALLOC(ndr, r->out.handle);
24464                 *r->out.handle = *r->in.handle;
24465         }
24466         if (flags & NDR_OUT) {
24467                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24468                         NDR_PULL_ALLOC(ndr, r->out.handle);
24469                 }
24470                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24471                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24472                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24474                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24475         }
24476         return NDR_ERR_SUCCESS;
24477 }
24478
24479 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
24480 {
24481         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
24482         ndr->depth++;
24483         if (flags & NDR_SET_VALUES) {
24484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24485         }
24486         if (flags & NDR_IN) {
24487                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
24488                 ndr->depth++;
24489                 ndr_print_ptr(ndr, "handle", r->in.handle);
24490                 ndr->depth++;
24491                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24492                 ndr->depth--;
24493                 ndr->depth--;
24494         }
24495         if (flags & NDR_OUT) {
24496                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
24497                 ndr->depth++;
24498                 ndr_print_ptr(ndr, "handle", r->out.handle);
24499                 ndr->depth++;
24500                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24501                 ndr->depth--;
24502                 ndr_print_WERROR(ndr, "result", r->out.result);
24503                 ndr->depth--;
24504         }
24505         ndr->depth--;
24506 }
24507
24508 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
24509 {
24510         if (flags & NDR_IN) {
24511                 if (r->in.handle == NULL) {
24512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24513                 }
24514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24516                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24517                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24518         }
24519         if (flags & NDR_OUT) {
24520                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24521         }
24522         return NDR_ERR_SUCCESS;
24523 }
24524
24525 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
24526 {
24527         TALLOC_CTX *_mem_save_handle_0;
24528         if (flags & NDR_IN) {
24529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24530                         NDR_PULL_ALLOC(ndr, r->in.handle);
24531                 }
24532                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24533                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24534                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24537                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24538                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24539         }
24540         if (flags & NDR_OUT) {
24541                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24542         }
24543         return NDR_ERR_SUCCESS;
24544 }
24545
24546 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
24547 {
24548         ndr_print_struct(ndr, name, "spoolss_AddForm");
24549         ndr->depth++;
24550         if (flags & NDR_SET_VALUES) {
24551                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24552         }
24553         if (flags & NDR_IN) {
24554                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24555                 ndr->depth++;
24556                 ndr_print_ptr(ndr, "handle", r->in.handle);
24557                 ndr->depth++;
24558                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24559                 ndr->depth--;
24560                 ndr_print_uint32(ndr, "level", r->in.level);
24561                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24562                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24563                 ndr->depth--;
24564         }
24565         if (flags & NDR_OUT) {
24566                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24567                 ndr->depth++;
24568                 ndr_print_WERROR(ndr, "result", r->out.result);
24569                 ndr->depth--;
24570         }
24571         ndr->depth--;
24572 }
24573
24574 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24575 {
24576         if (flags & NDR_IN) {
24577                 if (r->in.handle == NULL) {
24578                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24579                 }
24580                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24581                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24582                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24583                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24584                 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));
24585         }
24586         if (flags & NDR_OUT) {
24587                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24588         }
24589         return NDR_ERR_SUCCESS;
24590 }
24591
24592 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24593 {
24594         TALLOC_CTX *_mem_save_handle_0;
24595         if (flags & NDR_IN) {
24596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24597                         NDR_PULL_ALLOC(ndr, r->in.handle);
24598                 }
24599                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24600                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24601                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24603                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24604                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24605                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24606                         return 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));
24607                 }
24608                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24609                 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));
24610         }
24611         if (flags & NDR_OUT) {
24612                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24613         }
24614         return NDR_ERR_SUCCESS;
24615 }
24616
24617 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24618 {
24619         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24620         ndr->depth++;
24621         if (flags & NDR_SET_VALUES) {
24622                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24623         }
24624         if (flags & NDR_IN) {
24625                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24626                 ndr->depth++;
24627                 ndr_print_ptr(ndr, "handle", r->in.handle);
24628                 ndr->depth++;
24629                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24630                 ndr->depth--;
24631                 ndr_print_string(ndr, "form_name", r->in.form_name);
24632                 ndr->depth--;
24633         }
24634         if (flags & NDR_OUT) {
24635                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24636                 ndr->depth++;
24637                 ndr_print_WERROR(ndr, "result", r->out.result);
24638                 ndr->depth--;
24639         }
24640         ndr->depth--;
24641 }
24642
24643 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24644 {
24645         if (flags & NDR_IN) {
24646                 if (r->in.handle == NULL) {
24647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24648                 }
24649                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24650                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24651                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24652                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24653                 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));
24654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24656                 if (r->in.buffer) {
24657                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24658                 }
24659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24660         }
24661         if (flags & NDR_OUT) {
24662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24663                 if (r->out.info) {
24664                         {
24665                                 struct ndr_push *_ndr_info;
24666                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24667                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24668                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24669                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24670                         }
24671                 }
24672                 if (r->out.needed == NULL) {
24673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24674                 }
24675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24677         }
24678         return NDR_ERR_SUCCESS;
24679 }
24680
24681 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24682 {
24683         uint32_t _ptr_buffer;
24684         uint32_t _ptr_info;
24685         TALLOC_CTX *_mem_save_handle_0;
24686         TALLOC_CTX *_mem_save_buffer_0;
24687         TALLOC_CTX *_mem_save_info_0;
24688         TALLOC_CTX *_mem_save_needed_0;
24689         if (flags & NDR_IN) {
24690                 ZERO_STRUCT(r->out);
24691
24692                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24693                         NDR_PULL_ALLOC(ndr, r->in.handle);
24694                 }
24695                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24696                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24697                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24698                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24699                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24700                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24701                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24702                         return 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));
24703                 }
24704                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24705                 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));
24706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24708                 if (_ptr_buffer) {
24709                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24710                 } else {
24711                         r->in.buffer = NULL;
24712                 }
24713                 if (r->in.buffer) {
24714                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24715                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24716                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24718                 }
24719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24720                 NDR_PULL_ALLOC(ndr, r->out.needed);
24721                 ZERO_STRUCTP(r->out.needed);
24722         }
24723         if (flags & NDR_OUT) {
24724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24725                 if (_ptr_info) {
24726                         NDR_PULL_ALLOC(ndr, r->out.info);
24727                 } else {
24728                         r->out.info = NULL;
24729                 }
24730                 if (r->out.info) {
24731                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24732                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24733                         {
24734                                 struct ndr_pull *_ndr_info;
24735                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24736                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24737                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24738                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24739                         }
24740                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24741                 }
24742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24743                         NDR_PULL_ALLOC(ndr, r->out.needed);
24744                 }
24745                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24746                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24749                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24750         }
24751         return NDR_ERR_SUCCESS;
24752 }
24753
24754 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24755 {
24756         ndr_print_struct(ndr, name, "spoolss_GetForm");
24757         ndr->depth++;
24758         if (flags & NDR_SET_VALUES) {
24759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24760         }
24761         if (flags & NDR_IN) {
24762                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24763                 ndr->depth++;
24764                 ndr_print_ptr(ndr, "handle", r->in.handle);
24765                 ndr->depth++;
24766                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24767                 ndr->depth--;
24768                 ndr_print_string(ndr, "form_name", r->in.form_name);
24769                 ndr_print_uint32(ndr, "level", r->in.level);
24770                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24771                 ndr->depth++;
24772                 if (r->in.buffer) {
24773                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24774                 }
24775                 ndr->depth--;
24776                 ndr_print_uint32(ndr, "offered", r->in.offered);
24777                 ndr->depth--;
24778         }
24779         if (flags & NDR_OUT) {
24780                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24781                 ndr->depth++;
24782                 ndr_print_ptr(ndr, "info", r->out.info);
24783                 ndr->depth++;
24784                 if (r->out.info) {
24785                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24786                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24787                 }
24788                 ndr->depth--;
24789                 ndr_print_ptr(ndr, "needed", r->out.needed);
24790                 ndr->depth++;
24791                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24800 {
24801         if (flags & NDR_IN) {
24802                 if (r->in.handle == NULL) {
24803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24804                 }
24805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24806                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24807                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24808                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24809                 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));
24810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24811                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24812                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24813         }
24814         if (flags & NDR_OUT) {
24815                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24816         }
24817         return NDR_ERR_SUCCESS;
24818 }
24819
24820 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24821 {
24822         TALLOC_CTX *_mem_save_handle_0;
24823         if (flags & NDR_IN) {
24824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24825                         NDR_PULL_ALLOC(ndr, r->in.handle);
24826                 }
24827                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24828                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24829                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24831                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24832                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24833                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24834                         return 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));
24835                 }
24836                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24837                 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));
24838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24839                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24840                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24841         }
24842         if (flags & NDR_OUT) {
24843                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24844         }
24845         return NDR_ERR_SUCCESS;
24846 }
24847
24848 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24849 {
24850         ndr_print_struct(ndr, name, "spoolss_SetForm");
24851         ndr->depth++;
24852         if (flags & NDR_SET_VALUES) {
24853                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24854         }
24855         if (flags & NDR_IN) {
24856                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24857                 ndr->depth++;
24858                 ndr_print_ptr(ndr, "handle", r->in.handle);
24859                 ndr->depth++;
24860                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24861                 ndr->depth--;
24862                 ndr_print_string(ndr, "form_name", r->in.form_name);
24863                 ndr_print_uint32(ndr, "level", r->in.level);
24864                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24865                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24866                 ndr->depth--;
24867         }
24868         if (flags & NDR_OUT) {
24869                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24870                 ndr->depth++;
24871                 ndr_print_WERROR(ndr, "result", r->out.result);
24872                 ndr->depth--;
24873         }
24874         ndr->depth--;
24875 }
24876
24877 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24878 {
24879         if (flags & NDR_IN) {
24880                 if (r->in.handle == NULL) {
24881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24882                 }
24883                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24886                 if (r->in.buffer) {
24887                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24888                 }
24889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24890         }
24891         if (flags & NDR_OUT) {
24892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24893                 if (r->out.info) {
24894                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24895                 }
24896                 if (r->out.needed == NULL) {
24897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24898                 }
24899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24900                 if (r->out.count == NULL) {
24901                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24902                 }
24903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24905         }
24906         return NDR_ERR_SUCCESS;
24907 }
24908
24909 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24910 {
24911         uint32_t _ptr_buffer;
24912         uint32_t _ptr_info;
24913         TALLOC_CTX *_mem_save_handle_0;
24914         TALLOC_CTX *_mem_save_buffer_0;
24915         TALLOC_CTX *_mem_save_info_0;
24916         TALLOC_CTX *_mem_save_needed_0;
24917         TALLOC_CTX *_mem_save_count_0;
24918         if (flags & NDR_IN) {
24919                 ZERO_STRUCT(r->out);
24920
24921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24922                         NDR_PULL_ALLOC(ndr, r->in.handle);
24923                 }
24924                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24926                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24930                 if (_ptr_buffer) {
24931                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24932                 } else {
24933                         r->in.buffer = NULL;
24934                 }
24935                 if (r->in.buffer) {
24936                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24937                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24938                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24940                 }
24941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24942                 NDR_PULL_ALLOC(ndr, r->out.needed);
24943                 ZERO_STRUCTP(r->out.needed);
24944                 NDR_PULL_ALLOC(ndr, r->out.count);
24945                 ZERO_STRUCTP(r->out.count);
24946         }
24947         if (flags & NDR_OUT) {
24948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24949                 if (_ptr_info) {
24950                         NDR_PULL_ALLOC(ndr, r->out.info);
24951                 } else {
24952                         r->out.info = NULL;
24953                 }
24954                 if (r->out.info) {
24955                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24956                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24957                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24959                 }
24960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24961                         NDR_PULL_ALLOC(ndr, r->out.needed);
24962                 }
24963                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24968                         NDR_PULL_ALLOC(ndr, r->out.count);
24969                 }
24970                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24971                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24974                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24975         }
24976         return NDR_ERR_SUCCESS;
24977 }
24978
24979 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24980 {
24981         uint32_t cntr_info_0;
24982         if (flags & NDR_IN) {
24983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24985         }
24986         if (flags & NDR_OUT) {
24987                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24988                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24989                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24990                 }
24991                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24992                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24993                 }
24994         }
24995         return NDR_ERR_SUCCESS;
24996 }
24997
24998 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24999 {
25000         uint32_t cntr_info_0;
25001         TALLOC_CTX *_mem_save_info_0;
25002         if (flags & NDR_IN) {
25003                 ZERO_STRUCT(r->out);
25004
25005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25007         }
25008         if (flags & NDR_OUT) {
25009                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25010                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25012                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25013                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25014                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25015                 }
25016                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25017                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25018                 }
25019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25020         }
25021         return NDR_ERR_SUCCESS;
25022 }
25023
25024 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
25025 {
25026         uint32_t cntr_info_2;
25027         ndr_print_struct(ndr, name, "spoolss_EnumForms");
25028         ndr->depth++;
25029         if (flags & NDR_SET_VALUES) {
25030                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25031         }
25032         if (flags & NDR_IN) {
25033                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
25034                 ndr->depth++;
25035                 ndr_print_ptr(ndr, "handle", r->in.handle);
25036                 ndr->depth++;
25037                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25038                 ndr->depth--;
25039                 ndr_print_uint32(ndr, "level", r->in.level);
25040                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25041                 ndr->depth++;
25042                 if (r->in.buffer) {
25043                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25044                 }
25045                 ndr->depth--;
25046                 ndr_print_uint32(ndr, "offered", r->in.offered);
25047                 ndr->depth--;
25048         }
25049         if (flags & NDR_OUT) {
25050                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
25051                 ndr->depth++;
25052                 ndr_print_ptr(ndr, "count", r->out.count);
25053                 ndr->depth++;
25054                 ndr_print_uint32(ndr, "count", *r->out.count);
25055                 ndr->depth--;
25056                 ndr_print_ptr(ndr, "info", r->out.info);
25057                 ndr->depth++;
25058                 ndr_print_ptr(ndr, "info", *r->out.info);
25059                 ndr->depth++;
25060                 if (*r->out.info) {
25061                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25062                         ndr->depth++;
25063                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25064                                 char *idx_2=NULL;
25065                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25066                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25067                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25068                                         free(idx_2);
25069                                 }
25070                         }
25071                         ndr->depth--;
25072                 }
25073                 ndr->depth--;
25074                 ndr->depth--;
25075                 ndr_print_ptr(ndr, "needed", r->out.needed);
25076                 ndr->depth++;
25077                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25078                 ndr->depth--;
25079                 ndr_print_WERROR(ndr, "result", r->out.result);
25080                 ndr->depth--;
25081         }
25082         ndr->depth--;
25083 }
25084
25085 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
25086 {
25087         if (flags & NDR_IN) {
25088                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25089                 if (r->in.servername) {
25090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25094                 }
25095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25097                 if (r->in.buffer) {
25098                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25099                 }
25100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25101         }
25102         if (flags & NDR_OUT) {
25103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25104                 if (r->out.info) {
25105                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25106                 }
25107                 if (r->out.needed == NULL) {
25108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25109                 }
25110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25111                 if (r->out.count == NULL) {
25112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25113                 }
25114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25115                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25116         }
25117         return NDR_ERR_SUCCESS;
25118 }
25119
25120 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
25121 {
25122         uint32_t _ptr_servername;
25123         uint32_t _ptr_buffer;
25124         uint32_t _ptr_info;
25125         TALLOC_CTX *_mem_save_servername_0;
25126         TALLOC_CTX *_mem_save_buffer_0;
25127         TALLOC_CTX *_mem_save_info_0;
25128         TALLOC_CTX *_mem_save_needed_0;
25129         TALLOC_CTX *_mem_save_count_0;
25130         if (flags & NDR_IN) {
25131                 ZERO_STRUCT(r->out);
25132
25133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25134                 if (_ptr_servername) {
25135                         NDR_PULL_ALLOC(ndr, r->in.servername);
25136                 } else {
25137                         r->in.servername = NULL;
25138                 }
25139                 if (r->in.servername) {
25140                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25141                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25143                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25144                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25145                                 return 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));
25146                         }
25147                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25148                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25150                 }
25151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25153                 if (_ptr_buffer) {
25154                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25155                 } else {
25156                         r->in.buffer = NULL;
25157                 }
25158                 if (r->in.buffer) {
25159                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25160                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25161                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25163                 }
25164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25165                 NDR_PULL_ALLOC(ndr, r->out.needed);
25166                 ZERO_STRUCTP(r->out.needed);
25167                 NDR_PULL_ALLOC(ndr, r->out.count);
25168                 ZERO_STRUCTP(r->out.count);
25169         }
25170         if (flags & NDR_OUT) {
25171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25172                 if (_ptr_info) {
25173                         NDR_PULL_ALLOC(ndr, r->out.info);
25174                 } else {
25175                         r->out.info = NULL;
25176                 }
25177                 if (r->out.info) {
25178                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25179                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25180                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25182                 }
25183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25184                         NDR_PULL_ALLOC(ndr, r->out.needed);
25185                 }
25186                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25191                         NDR_PULL_ALLOC(ndr, r->out.count);
25192                 }
25193                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25194                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25198         }
25199         return NDR_ERR_SUCCESS;
25200 }
25201
25202 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
25203 {
25204         uint32_t cntr_info_0;
25205         if (flags & NDR_IN) {
25206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25208         }
25209         if (flags & NDR_OUT) {
25210                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25211                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25212                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25213                 }
25214                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25215                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25216                 }
25217         }
25218         return NDR_ERR_SUCCESS;
25219 }
25220
25221 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
25222 {
25223         uint32_t cntr_info_0;
25224         TALLOC_CTX *_mem_save_info_0;
25225         if (flags & NDR_IN) {
25226                 ZERO_STRUCT(r->out);
25227
25228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25230         }
25231         if (flags & NDR_OUT) {
25232                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25233                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25234                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25235                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25236                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25237                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25238                 }
25239                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25240                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25241                 }
25242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25243         }
25244         return NDR_ERR_SUCCESS;
25245 }
25246
25247 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
25248 {
25249         uint32_t cntr_info_2;
25250         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
25251         ndr->depth++;
25252         if (flags & NDR_SET_VALUES) {
25253                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25254         }
25255         if (flags & NDR_IN) {
25256                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
25257                 ndr->depth++;
25258                 ndr_print_ptr(ndr, "servername", r->in.servername);
25259                 ndr->depth++;
25260                 if (r->in.servername) {
25261                         ndr_print_string(ndr, "servername", r->in.servername);
25262                 }
25263                 ndr->depth--;
25264                 ndr_print_uint32(ndr, "level", r->in.level);
25265                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25266                 ndr->depth++;
25267                 if (r->in.buffer) {
25268                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25269                 }
25270                 ndr->depth--;
25271                 ndr_print_uint32(ndr, "offered", r->in.offered);
25272                 ndr->depth--;
25273         }
25274         if (flags & NDR_OUT) {
25275                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
25276                 ndr->depth++;
25277                 ndr_print_ptr(ndr, "count", r->out.count);
25278                 ndr->depth++;
25279                 ndr_print_uint32(ndr, "count", *r->out.count);
25280                 ndr->depth--;
25281                 ndr_print_ptr(ndr, "info", r->out.info);
25282                 ndr->depth++;
25283                 ndr_print_ptr(ndr, "info", *r->out.info);
25284                 ndr->depth++;
25285                 if (*r->out.info) {
25286                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25287                         ndr->depth++;
25288                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25289                                 char *idx_2=NULL;
25290                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25291                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25292                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25293                                         free(idx_2);
25294                                 }
25295                         }
25296                         ndr->depth--;
25297                 }
25298                 ndr->depth--;
25299                 ndr->depth--;
25300                 ndr_print_ptr(ndr, "needed", r->out.needed);
25301                 ndr->depth++;
25302                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25303                 ndr->depth--;
25304                 ndr_print_WERROR(ndr, "result", r->out.result);
25305                 ndr->depth--;
25306         }
25307         ndr->depth--;
25308 }
25309
25310 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
25311 {
25312         if (flags & NDR_IN) {
25313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25314                 if (r->in.servername) {
25315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25318                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25319                 }
25320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25321                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25322                 if (r->in.buffer) {
25323                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25324                 }
25325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25326         }
25327         if (flags & NDR_OUT) {
25328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25329                 if (r->out.info) {
25330                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25331                 }
25332                 if (r->out.needed == NULL) {
25333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25334                 }
25335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25336                 if (r->out.count == NULL) {
25337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25338                 }
25339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25341         }
25342         return NDR_ERR_SUCCESS;
25343 }
25344
25345 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
25346 {
25347         uint32_t _ptr_servername;
25348         uint32_t _ptr_buffer;
25349         uint32_t _ptr_info;
25350         TALLOC_CTX *_mem_save_servername_0;
25351         TALLOC_CTX *_mem_save_buffer_0;
25352         TALLOC_CTX *_mem_save_info_0;
25353         TALLOC_CTX *_mem_save_needed_0;
25354         TALLOC_CTX *_mem_save_count_0;
25355         if (flags & NDR_IN) {
25356                 ZERO_STRUCT(r->out);
25357
25358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25359                 if (_ptr_servername) {
25360                         NDR_PULL_ALLOC(ndr, r->in.servername);
25361                 } else {
25362                         r->in.servername = NULL;
25363                 }
25364                 if (r->in.servername) {
25365                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25366                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25369                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25370                                 return 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));
25371                         }
25372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25373                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25375                 }
25376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25378                 if (_ptr_buffer) {
25379                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25380                 } else {
25381                         r->in.buffer = NULL;
25382                 }
25383                 if (r->in.buffer) {
25384                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25385                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25386                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25388                 }
25389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25390                 NDR_PULL_ALLOC(ndr, r->out.needed);
25391                 ZERO_STRUCTP(r->out.needed);
25392                 NDR_PULL_ALLOC(ndr, r->out.count);
25393                 ZERO_STRUCTP(r->out.count);
25394         }
25395         if (flags & NDR_OUT) {
25396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25397                 if (_ptr_info) {
25398                         NDR_PULL_ALLOC(ndr, r->out.info);
25399                 } else {
25400                         r->out.info = NULL;
25401                 }
25402                 if (r->out.info) {
25403                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25404                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25405                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25407                 }
25408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25409                         NDR_PULL_ALLOC(ndr, r->out.needed);
25410                 }
25411                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25412                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25415                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25416                         NDR_PULL_ALLOC(ndr, r->out.count);
25417                 }
25418                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25419                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25423         }
25424         return NDR_ERR_SUCCESS;
25425 }
25426
25427 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
25428 {
25429         uint32_t cntr_info_0;
25430         if (flags & NDR_IN) {
25431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25433         }
25434         if (flags & NDR_OUT) {
25435                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25436                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25437                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25438                 }
25439                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25440                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25441                 }
25442         }
25443         return NDR_ERR_SUCCESS;
25444 }
25445
25446 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
25447 {
25448         uint32_t cntr_info_0;
25449         TALLOC_CTX *_mem_save_info_0;
25450         if (flags & NDR_IN) {
25451                 ZERO_STRUCT(r->out);
25452
25453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25455         }
25456         if (flags & NDR_OUT) {
25457                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25458                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25459                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25460                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25461                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25462                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25463                 }
25464                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25465                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25466                 }
25467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25468         }
25469         return NDR_ERR_SUCCESS;
25470 }
25471
25472 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
25473 {
25474         uint32_t cntr_info_2;
25475         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
25476         ndr->depth++;
25477         if (flags & NDR_SET_VALUES) {
25478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25479         }
25480         if (flags & NDR_IN) {
25481                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
25482                 ndr->depth++;
25483                 ndr_print_ptr(ndr, "servername", r->in.servername);
25484                 ndr->depth++;
25485                 if (r->in.servername) {
25486                         ndr_print_string(ndr, "servername", r->in.servername);
25487                 }
25488                 ndr->depth--;
25489                 ndr_print_uint32(ndr, "level", r->in.level);
25490                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25491                 ndr->depth++;
25492                 if (r->in.buffer) {
25493                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25494                 }
25495                 ndr->depth--;
25496                 ndr_print_uint32(ndr, "offered", r->in.offered);
25497                 ndr->depth--;
25498         }
25499         if (flags & NDR_OUT) {
25500                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
25501                 ndr->depth++;
25502                 ndr_print_ptr(ndr, "count", r->out.count);
25503                 ndr->depth++;
25504                 ndr_print_uint32(ndr, "count", *r->out.count);
25505                 ndr->depth--;
25506                 ndr_print_ptr(ndr, "info", r->out.info);
25507                 ndr->depth++;
25508                 ndr_print_ptr(ndr, "info", *r->out.info);
25509                 ndr->depth++;
25510                 if (*r->out.info) {
25511                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25512                         ndr->depth++;
25513                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25514                                 char *idx_2=NULL;
25515                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25516                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25517                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25518                                         free(idx_2);
25519                                 }
25520                         }
25521                         ndr->depth--;
25522                 }
25523                 ndr->depth--;
25524                 ndr->depth--;
25525                 ndr_print_ptr(ndr, "needed", r->out.needed);
25526                 ndr->depth++;
25527                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25528                 ndr->depth--;
25529                 ndr_print_WERROR(ndr, "result", r->out.result);
25530                 ndr->depth--;
25531         }
25532         ndr->depth--;
25533 }
25534
25535 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
25536 {
25537         if (flags & NDR_IN) {
25538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
25539                 if (r->in.server_name) {
25540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25542                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
25543                         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));
25544                 }
25545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
25546                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25547                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25548                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
25549                 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));
25550         }
25551         if (flags & NDR_OUT) {
25552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25553         }
25554         return NDR_ERR_SUCCESS;
25555 }
25556
25557 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25558 {
25559         uint32_t _ptr_server_name;
25560         TALLOC_CTX *_mem_save_server_name_0;
25561         if (flags & NDR_IN) {
25562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25563                 if (_ptr_server_name) {
25564                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25565                 } else {
25566                         r->in.server_name = NULL;
25567                 }
25568                 if (r->in.server_name) {
25569                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25570                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25573                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25574                                 return 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));
25575                         }
25576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25577                         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));
25578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25579                 }
25580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25581                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25582                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25583                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25584                         return 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));
25585                 }
25586                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25587                 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));
25588         }
25589         if (flags & NDR_OUT) {
25590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25591         }
25592         return NDR_ERR_SUCCESS;
25593 }
25594
25595 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25596 {
25597         ndr_print_struct(ndr, name, "spoolss_AddPort");
25598         ndr->depth++;
25599         if (flags & NDR_SET_VALUES) {
25600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25601         }
25602         if (flags & NDR_IN) {
25603                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25604                 ndr->depth++;
25605                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25606                 ndr->depth++;
25607                 if (r->in.server_name) {
25608                         ndr_print_string(ndr, "server_name", r->in.server_name);
25609                 }
25610                 ndr->depth--;
25611                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25612                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25613                 ndr->depth--;
25614         }
25615         if (flags & NDR_OUT) {
25616                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25617                 ndr->depth++;
25618                 ndr_print_WERROR(ndr, "result", r->out.result);
25619                 ndr->depth--;
25620         }
25621         ndr->depth--;
25622 }
25623
25624 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25625 {
25626         if (flags & NDR_IN) {
25627         }
25628         if (flags & NDR_OUT) {
25629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25630         }
25631         return NDR_ERR_SUCCESS;
25632 }
25633
25634 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25635 {
25636         if (flags & NDR_IN) {
25637         }
25638         if (flags & NDR_OUT) {
25639                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25640         }
25641         return NDR_ERR_SUCCESS;
25642 }
25643
25644 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25645 {
25646         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25647         ndr->depth++;
25648         if (flags & NDR_SET_VALUES) {
25649                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25650         }
25651         if (flags & NDR_IN) {
25652                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25653                 ndr->depth++;
25654                 ndr->depth--;
25655         }
25656         if (flags & NDR_OUT) {
25657                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25658                 ndr->depth++;
25659                 ndr_print_WERROR(ndr, "result", r->out.result);
25660                 ndr->depth--;
25661         }
25662         ndr->depth--;
25663 }
25664
25665 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25666 {
25667         if (flags & NDR_IN) {
25668         }
25669         if (flags & NDR_OUT) {
25670                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25671         }
25672         return NDR_ERR_SUCCESS;
25673 }
25674
25675 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25676 {
25677         if (flags & NDR_IN) {
25678         }
25679         if (flags & NDR_OUT) {
25680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25681         }
25682         return NDR_ERR_SUCCESS;
25683 }
25684
25685 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25686 {
25687         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25688         ndr->depth++;
25689         if (flags & NDR_SET_VALUES) {
25690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25691         }
25692         if (flags & NDR_IN) {
25693                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25694                 ndr->depth++;
25695                 ndr->depth--;
25696         }
25697         if (flags & NDR_OUT) {
25698                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25699                 ndr->depth++;
25700                 ndr_print_WERROR(ndr, "result", r->out.result);
25701                 ndr->depth--;
25702         }
25703         ndr->depth--;
25704 }
25705
25706 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25707 {
25708         if (flags & NDR_IN) {
25709                 if (r->in.handle == NULL) {
25710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25711                 }
25712                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25713                 if (r->in.devmode_ctr == NULL) {
25714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25715                 }
25716                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25717         }
25718         if (flags & NDR_OUT) {
25719                 if (r->out.gdi_handle == NULL) {
25720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25721                 }
25722                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25723                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25724         }
25725         return NDR_ERR_SUCCESS;
25726 }
25727
25728 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25729 {
25730         TALLOC_CTX *_mem_save_handle_0;
25731         TALLOC_CTX *_mem_save_gdi_handle_0;
25732         TALLOC_CTX *_mem_save_devmode_ctr_0;
25733         if (flags & NDR_IN) {
25734                 ZERO_STRUCT(r->out);
25735
25736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25737                         NDR_PULL_ALLOC(ndr, r->in.handle);
25738                 }
25739                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25744                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25745                 }
25746                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25747                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25748                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25750                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25751                 ZERO_STRUCTP(r->out.gdi_handle);
25752         }
25753         if (flags & NDR_OUT) {
25754                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25755                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25756                 }
25757                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25758                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25759                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25760                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25761                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25762         }
25763         return NDR_ERR_SUCCESS;
25764 }
25765
25766 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25767 {
25768         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25769         ndr->depth++;
25770         if (flags & NDR_SET_VALUES) {
25771                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25772         }
25773         if (flags & NDR_IN) {
25774                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25775                 ndr->depth++;
25776                 ndr_print_ptr(ndr, "handle", r->in.handle);
25777                 ndr->depth++;
25778                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25779                 ndr->depth--;
25780                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25781                 ndr->depth++;
25782                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25783                 ndr->depth--;
25784                 ndr->depth--;
25785         }
25786         if (flags & NDR_OUT) {
25787                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25788                 ndr->depth++;
25789                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25790                 ndr->depth++;
25791                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25792                 ndr->depth--;
25793                 ndr_print_WERROR(ndr, "result", r->out.result);
25794                 ndr->depth--;
25795         }
25796         ndr->depth--;
25797 }
25798
25799 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25800 {
25801         if (flags & NDR_IN) {
25802         }
25803         if (flags & NDR_OUT) {
25804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25805         }
25806         return NDR_ERR_SUCCESS;
25807 }
25808
25809 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25810 {
25811         if (flags & NDR_IN) {
25812         }
25813         if (flags & NDR_OUT) {
25814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25815         }
25816         return NDR_ERR_SUCCESS;
25817 }
25818
25819 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25820 {
25821         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25822         ndr->depth++;
25823         if (flags & NDR_SET_VALUES) {
25824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25825         }
25826         if (flags & NDR_IN) {
25827                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25828                 ndr->depth++;
25829                 ndr->depth--;
25830         }
25831         if (flags & NDR_OUT) {
25832                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25833                 ndr->depth++;
25834                 ndr_print_WERROR(ndr, "result", r->out.result);
25835                 ndr->depth--;
25836         }
25837         ndr->depth--;
25838 }
25839
25840 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25841 {
25842         if (flags & NDR_IN) {
25843                 if (r->in.gdi_handle == NULL) {
25844                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25845                 }
25846                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25847         }
25848         if (flags & NDR_OUT) {
25849                 if (r->out.gdi_handle == NULL) {
25850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25851                 }
25852                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25853                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25854         }
25855         return NDR_ERR_SUCCESS;
25856 }
25857
25858 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25859 {
25860         TALLOC_CTX *_mem_save_gdi_handle_0;
25861         if (flags & NDR_IN) {
25862                 ZERO_STRUCT(r->out);
25863
25864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25865                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25866                 }
25867                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25868                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25869                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25871                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25872                 *r->out.gdi_handle = *r->in.gdi_handle;
25873         }
25874         if (flags & NDR_OUT) {
25875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25876                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25877                 }
25878                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25879                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25882                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25883         }
25884         return NDR_ERR_SUCCESS;
25885 }
25886
25887 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25888 {
25889         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25890         ndr->depth++;
25891         if (flags & NDR_SET_VALUES) {
25892                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25893         }
25894         if (flags & NDR_IN) {
25895                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25896                 ndr->depth++;
25897                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25898                 ndr->depth++;
25899                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25900                 ndr->depth--;
25901                 ndr->depth--;
25902         }
25903         if (flags & NDR_OUT) {
25904                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25905                 ndr->depth++;
25906                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25907                 ndr->depth++;
25908                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25909                 ndr->depth--;
25910                 ndr_print_WERROR(ndr, "result", r->out.result);
25911                 ndr->depth--;
25912         }
25913         ndr->depth--;
25914 }
25915
25916 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25917 {
25918         if (flags & NDR_IN) {
25919         }
25920         if (flags & NDR_OUT) {
25921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25922         }
25923         return NDR_ERR_SUCCESS;
25924 }
25925
25926 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25927 {
25928         if (flags & NDR_IN) {
25929         }
25930         if (flags & NDR_OUT) {
25931                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25932         }
25933         return NDR_ERR_SUCCESS;
25934 }
25935
25936 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25937 {
25938         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25939         ndr->depth++;
25940         if (flags & NDR_SET_VALUES) {
25941                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25942         }
25943         if (flags & NDR_IN) {
25944                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25945                 ndr->depth++;
25946                 ndr->depth--;
25947         }
25948         if (flags & NDR_OUT) {
25949                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25950                 ndr->depth++;
25951                 ndr_print_WERROR(ndr, "result", r->out.result);
25952                 ndr->depth--;
25953         }
25954         ndr->depth--;
25955 }
25956
25957 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25958 {
25959         if (flags & NDR_IN) {
25960         }
25961         if (flags & NDR_OUT) {
25962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25963         }
25964         return NDR_ERR_SUCCESS;
25965 }
25966
25967 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25968 {
25969         if (flags & NDR_IN) {
25970         }
25971         if (flags & NDR_OUT) {
25972                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25973         }
25974         return NDR_ERR_SUCCESS;
25975 }
25976
25977 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25978 {
25979         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25980         ndr->depth++;
25981         if (flags & NDR_SET_VALUES) {
25982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25983         }
25984         if (flags & NDR_IN) {
25985                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25986                 ndr->depth++;
25987                 ndr->depth--;
25988         }
25989         if (flags & NDR_OUT) {
25990                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25991                 ndr->depth++;
25992                 ndr_print_WERROR(ndr, "result", r->out.result);
25993                 ndr->depth--;
25994         }
25995         ndr->depth--;
25996 }
25997
25998 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25999 {
26000         if (flags & NDR_IN) {
26001         }
26002         if (flags & NDR_OUT) {
26003                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26004         }
26005         return NDR_ERR_SUCCESS;
26006 }
26007
26008 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
26009 {
26010         if (flags & NDR_IN) {
26011         }
26012         if (flags & NDR_OUT) {
26013                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26014         }
26015         return NDR_ERR_SUCCESS;
26016 }
26017
26018 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
26019 {
26020         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
26021         ndr->depth++;
26022         if (flags & NDR_SET_VALUES) {
26023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26024         }
26025         if (flags & NDR_IN) {
26026                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
26027                 ndr->depth++;
26028                 ndr->depth--;
26029         }
26030         if (flags & NDR_OUT) {
26031                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
26032                 ndr->depth++;
26033                 ndr_print_WERROR(ndr, "result", r->out.result);
26034                 ndr->depth--;
26035         }
26036         ndr->depth--;
26037 }
26038
26039 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
26040 {
26041         if (flags & NDR_IN) {
26042         }
26043         if (flags & NDR_OUT) {
26044                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26045         }
26046         return NDR_ERR_SUCCESS;
26047 }
26048
26049 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
26050 {
26051         if (flags & NDR_IN) {
26052         }
26053         if (flags & NDR_OUT) {
26054                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26055         }
26056         return NDR_ERR_SUCCESS;
26057 }
26058
26059 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
26060 {
26061         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
26062         ndr->depth++;
26063         if (flags & NDR_SET_VALUES) {
26064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26065         }
26066         if (flags & NDR_IN) {
26067                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
26068                 ndr->depth++;
26069                 ndr->depth--;
26070         }
26071         if (flags & NDR_OUT) {
26072                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
26073                 ndr->depth++;
26074                 ndr_print_WERROR(ndr, "result", r->out.result);
26075                 ndr->depth--;
26076         }
26077         ndr->depth--;
26078 }
26079
26080 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
26081 {
26082         if (flags & NDR_IN) {
26083         }
26084         if (flags & NDR_OUT) {
26085                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26086         }
26087         return NDR_ERR_SUCCESS;
26088 }
26089
26090 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
26091 {
26092         if (flags & NDR_IN) {
26093         }
26094         if (flags & NDR_OUT) {
26095                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26096         }
26097         return NDR_ERR_SUCCESS;
26098 }
26099
26100 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
26101 {
26102         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
26103         ndr->depth++;
26104         if (flags & NDR_SET_VALUES) {
26105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26106         }
26107         if (flags & NDR_IN) {
26108                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
26109                 ndr->depth++;
26110                 ndr->depth--;
26111         }
26112         if (flags & NDR_OUT) {
26113                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
26114                 ndr->depth++;
26115                 ndr_print_WERROR(ndr, "result", r->out.result);
26116                 ndr->depth--;
26117         }
26118         ndr->depth--;
26119 }
26120
26121 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
26122 {
26123         if (flags & NDR_IN) {
26124         }
26125         if (flags & NDR_OUT) {
26126                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26127         }
26128         return NDR_ERR_SUCCESS;
26129 }
26130
26131 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
26132 {
26133         if (flags & NDR_IN) {
26134         }
26135         if (flags & NDR_OUT) {
26136                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26137         }
26138         return NDR_ERR_SUCCESS;
26139 }
26140
26141 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
26142 {
26143         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
26144         ndr->depth++;
26145         if (flags & NDR_SET_VALUES) {
26146                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26147         }
26148         if (flags & NDR_IN) {
26149                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
26150                 ndr->depth++;
26151                 ndr->depth--;
26152         }
26153         if (flags & NDR_OUT) {
26154                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
26155                 ndr->depth++;
26156                 ndr_print_WERROR(ndr, "result", r->out.result);
26157                 ndr->depth--;
26158         }
26159         ndr->depth--;
26160 }
26161
26162 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
26163 {
26164         if (flags & NDR_IN) {
26165         }
26166         if (flags & NDR_OUT) {
26167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26168         }
26169         return NDR_ERR_SUCCESS;
26170 }
26171
26172 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
26173 {
26174         if (flags & NDR_IN) {
26175         }
26176         if (flags & NDR_OUT) {
26177                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26178         }
26179         return NDR_ERR_SUCCESS;
26180 }
26181
26182 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
26183 {
26184         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
26185         ndr->depth++;
26186         if (flags & NDR_SET_VALUES) {
26187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26188         }
26189         if (flags & NDR_IN) {
26190                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
26191                 ndr->depth++;
26192                 ndr->depth--;
26193         }
26194         if (flags & NDR_OUT) {
26195                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
26196                 ndr->depth++;
26197                 ndr_print_WERROR(ndr, "result", r->out.result);
26198                 ndr->depth--;
26199         }
26200         ndr->depth--;
26201 }
26202
26203 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
26204 {
26205         if (flags & NDR_IN) {
26206         }
26207         if (flags & NDR_OUT) {
26208                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26209         }
26210         return NDR_ERR_SUCCESS;
26211 }
26212
26213 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
26214 {
26215         if (flags & NDR_IN) {
26216         }
26217         if (flags & NDR_OUT) {
26218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26219         }
26220         return NDR_ERR_SUCCESS;
26221 }
26222
26223 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
26224 {
26225         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
26226         ndr->depth++;
26227         if (flags & NDR_SET_VALUES) {
26228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26229         }
26230         if (flags & NDR_IN) {
26231                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
26232                 ndr->depth++;
26233                 ndr->depth--;
26234         }
26235         if (flags & NDR_OUT) {
26236                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
26237                 ndr->depth++;
26238                 ndr_print_WERROR(ndr, "result", r->out.result);
26239                 ndr->depth--;
26240         }
26241         ndr->depth--;
26242 }
26243
26244 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
26245 {
26246         if (flags & NDR_IN) {
26247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26248                 if (r->in.servername) {
26249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26253                 }
26254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
26255                 if (r->in.print_processor_name) {
26256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
26259                         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));
26260                 }
26261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26262                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26263                 if (r->in.buffer) {
26264                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26265                 }
26266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26267         }
26268         if (flags & NDR_OUT) {
26269                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26270                 if (r->out.info) {
26271                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
26272                 }
26273                 if (r->out.needed == NULL) {
26274                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26275                 }
26276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26277                 if (r->out.count == NULL) {
26278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26279                 }
26280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26282         }
26283         return NDR_ERR_SUCCESS;
26284 }
26285
26286 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
26287 {
26288         uint32_t _ptr_servername;
26289         uint32_t _ptr_print_processor_name;
26290         uint32_t _ptr_buffer;
26291         uint32_t _ptr_info;
26292         TALLOC_CTX *_mem_save_servername_0;
26293         TALLOC_CTX *_mem_save_print_processor_name_0;
26294         TALLOC_CTX *_mem_save_buffer_0;
26295         TALLOC_CTX *_mem_save_info_0;
26296         TALLOC_CTX *_mem_save_needed_0;
26297         TALLOC_CTX *_mem_save_count_0;
26298         if (flags & NDR_IN) {
26299                 ZERO_STRUCT(r->out);
26300
26301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26302                 if (_ptr_servername) {
26303                         NDR_PULL_ALLOC(ndr, r->in.servername);
26304                 } else {
26305                         r->in.servername = NULL;
26306                 }
26307                 if (r->in.servername) {
26308                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26309                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26312                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26313                                 return 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));
26314                         }
26315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26318                 }
26319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
26320                 if (_ptr_print_processor_name) {
26321                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
26322                 } else {
26323                         r->in.print_processor_name = NULL;
26324                 }
26325                 if (r->in.print_processor_name) {
26326                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
26327                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
26328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
26329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
26330                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
26331                                 return 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));
26332                         }
26333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
26334                         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));
26335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
26336                 }
26337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26339                 if (_ptr_buffer) {
26340                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26341                 } else {
26342                         r->in.buffer = NULL;
26343                 }
26344                 if (r->in.buffer) {
26345                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26346                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26347                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26349                 }
26350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26351                 NDR_PULL_ALLOC(ndr, r->out.needed);
26352                 ZERO_STRUCTP(r->out.needed);
26353                 NDR_PULL_ALLOC(ndr, r->out.count);
26354                 ZERO_STRUCTP(r->out.count);
26355         }
26356         if (flags & NDR_OUT) {
26357                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26358                 if (_ptr_info) {
26359                         NDR_PULL_ALLOC(ndr, r->out.info);
26360                 } else {
26361                         r->out.info = NULL;
26362                 }
26363                 if (r->out.info) {
26364                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26365                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26366                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26368                 }
26369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26370                         NDR_PULL_ALLOC(ndr, r->out.needed);
26371                 }
26372                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26373                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26376                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26377                         NDR_PULL_ALLOC(ndr, r->out.count);
26378                 }
26379                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26380                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26384         }
26385         return NDR_ERR_SUCCESS;
26386 }
26387
26388 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
26389 {
26390         uint32_t cntr_info_0;
26391         if (flags & NDR_IN) {
26392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26394         }
26395         if (flags & NDR_OUT) {
26396                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26397                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26398                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26399                 }
26400                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26401                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26402                 }
26403         }
26404         return NDR_ERR_SUCCESS;
26405 }
26406
26407 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
26408 {
26409         uint32_t cntr_info_0;
26410         TALLOC_CTX *_mem_save_info_0;
26411         if (flags & NDR_IN) {
26412                 ZERO_STRUCT(r->out);
26413
26414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26416         }
26417         if (flags & NDR_OUT) {
26418                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26419                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26420                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26421                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26422                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
26423                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26424                 }
26425                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26426                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26427                 }
26428                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26429         }
26430         return NDR_ERR_SUCCESS;
26431 }
26432
26433 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
26434 {
26435         uint32_t cntr_info_2;
26436         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
26437         ndr->depth++;
26438         if (flags & NDR_SET_VALUES) {
26439                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26440         }
26441         if (flags & NDR_IN) {
26442                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
26443                 ndr->depth++;
26444                 ndr_print_ptr(ndr, "servername", r->in.servername);
26445                 ndr->depth++;
26446                 if (r->in.servername) {
26447                         ndr_print_string(ndr, "servername", r->in.servername);
26448                 }
26449                 ndr->depth--;
26450                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
26451                 ndr->depth++;
26452                 if (r->in.print_processor_name) {
26453                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
26454                 }
26455                 ndr->depth--;
26456                 ndr_print_uint32(ndr, "level", r->in.level);
26457                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26458                 ndr->depth++;
26459                 if (r->in.buffer) {
26460                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26461                 }
26462                 ndr->depth--;
26463                 ndr_print_uint32(ndr, "offered", r->in.offered);
26464                 ndr->depth--;
26465         }
26466         if (flags & NDR_OUT) {
26467                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
26468                 ndr->depth++;
26469                 ndr_print_ptr(ndr, "count", r->out.count);
26470                 ndr->depth++;
26471                 ndr_print_uint32(ndr, "count", *r->out.count);
26472                 ndr->depth--;
26473                 ndr_print_ptr(ndr, "info", r->out.info);
26474                 ndr->depth++;
26475                 ndr_print_ptr(ndr, "info", *r->out.info);
26476                 ndr->depth++;
26477                 if (*r->out.info) {
26478                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26479                         ndr->depth++;
26480                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26481                                 char *idx_2=NULL;
26482                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26483                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
26484                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
26485                                         free(idx_2);
26486                                 }
26487                         }
26488                         ndr->depth--;
26489                 }
26490                 ndr->depth--;
26491                 ndr->depth--;
26492                 ndr_print_ptr(ndr, "needed", r->out.needed);
26493                 ndr->depth++;
26494                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26495                 ndr->depth--;
26496                 ndr_print_WERROR(ndr, "result", r->out.result);
26497                 ndr->depth--;
26498         }
26499         ndr->depth--;
26500 }
26501
26502 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
26503 {
26504         if (flags & NDR_IN) {
26505                 if (r->in.handle == NULL) {
26506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26507                 }
26508                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
26510                 if (r->in.data_type) {
26511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
26514                         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));
26515                 }
26516                 if (r->in.devmode_ctr == NULL) {
26517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26518                 }
26519                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26520         }
26521         if (flags & NDR_OUT) {
26522                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26523         }
26524         return NDR_ERR_SUCCESS;
26525 }
26526
26527 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
26528 {
26529         uint32_t _ptr_data_type;
26530         TALLOC_CTX *_mem_save_handle_0;
26531         TALLOC_CTX *_mem_save_data_type_0;
26532         TALLOC_CTX *_mem_save_devmode_ctr_0;
26533         if (flags & NDR_IN) {
26534                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26535                         NDR_PULL_ALLOC(ndr, r->in.handle);
26536                 }
26537                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26538                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26539                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
26542                 if (_ptr_data_type) {
26543                         NDR_PULL_ALLOC(ndr, r->in.data_type);
26544                 } else {
26545                         r->in.data_type = NULL;
26546                 }
26547                 if (r->in.data_type) {
26548                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
26550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
26551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
26552                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
26553                                 return 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));
26554                         }
26555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26556                         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));
26557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26558                 }
26559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26560                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26561                 }
26562                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26563                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26564                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26566         }
26567         if (flags & NDR_OUT) {
26568                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26569         }
26570         return NDR_ERR_SUCCESS;
26571 }
26572
26573 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26574 {
26575         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26576         ndr->depth++;
26577         if (flags & NDR_SET_VALUES) {
26578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26579         }
26580         if (flags & NDR_IN) {
26581                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26582                 ndr->depth++;
26583                 ndr_print_ptr(ndr, "handle", r->in.handle);
26584                 ndr->depth++;
26585                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26586                 ndr->depth--;
26587                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26588                 ndr->depth++;
26589                 if (r->in.data_type) {
26590                         ndr_print_string(ndr, "data_type", r->in.data_type);
26591                 }
26592                 ndr->depth--;
26593                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26594                 ndr->depth++;
26595                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26596                 ndr->depth--;
26597                 ndr->depth--;
26598         }
26599         if (flags & NDR_OUT) {
26600                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26601                 ndr->depth++;
26602                 ndr_print_WERROR(ndr, "result", r->out.result);
26603                 ndr->depth--;
26604         }
26605         ndr->depth--;
26606 }
26607
26608 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26609 {
26610         if (flags & NDR_IN) {
26611                 if (r->in.handle == NULL) {
26612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26613                 }
26614                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26616                 if (r->in.architecture) {
26617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26620                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26621                 }
26622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26624                 if (r->in.buffer) {
26625                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26626                 }
26627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26630         }
26631         if (flags & NDR_OUT) {
26632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26633                 if (r->out.info) {
26634                         {
26635                                 struct ndr_push *_ndr_info;
26636                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26637                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26638                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26639                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26640                         }
26641                 }
26642                 if (r->out.needed == NULL) {
26643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26644                 }
26645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26646                 if (r->out.server_major_version == NULL) {
26647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26648                 }
26649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26650                 if (r->out.server_minor_version == NULL) {
26651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26652                 }
26653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26654                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26655         }
26656         return NDR_ERR_SUCCESS;
26657 }
26658
26659 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26660 {
26661         uint32_t _ptr_architecture;
26662         uint32_t _ptr_buffer;
26663         uint32_t _ptr_info;
26664         TALLOC_CTX *_mem_save_handle_0;
26665         TALLOC_CTX *_mem_save_architecture_0;
26666         TALLOC_CTX *_mem_save_buffer_0;
26667         TALLOC_CTX *_mem_save_info_0;
26668         TALLOC_CTX *_mem_save_needed_0;
26669         TALLOC_CTX *_mem_save_server_major_version_0;
26670         TALLOC_CTX *_mem_save_server_minor_version_0;
26671         if (flags & NDR_IN) {
26672                 ZERO_STRUCT(r->out);
26673
26674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26675                         NDR_PULL_ALLOC(ndr, r->in.handle);
26676                 }
26677                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26679                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26682                 if (_ptr_architecture) {
26683                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26684                 } else {
26685                         r->in.architecture = NULL;
26686                 }
26687                 if (r->in.architecture) {
26688                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26689                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26692                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26693                                 return 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));
26694                         }
26695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26698                 }
26699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26701                 if (_ptr_buffer) {
26702                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26703                 } else {
26704                         r->in.buffer = NULL;
26705                 }
26706                 if (r->in.buffer) {
26707                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26708                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26709                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26710                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26711                 }
26712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26715                 NDR_PULL_ALLOC(ndr, r->out.needed);
26716                 ZERO_STRUCTP(r->out.needed);
26717                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26718                 ZERO_STRUCTP(r->out.server_major_version);
26719                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26720                 ZERO_STRUCTP(r->out.server_minor_version);
26721         }
26722         if (flags & NDR_OUT) {
26723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26724                 if (_ptr_info) {
26725                         NDR_PULL_ALLOC(ndr, r->out.info);
26726                 } else {
26727                         r->out.info = NULL;
26728                 }
26729                 if (r->out.info) {
26730                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26731                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26732                         {
26733                                 struct ndr_pull *_ndr_info;
26734                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26735                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26736                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26737                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26738                         }
26739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26740                 }
26741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26742                         NDR_PULL_ALLOC(ndr, r->out.needed);
26743                 }
26744                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26745                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26749                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26750                 }
26751                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26752                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26754                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26755                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26756                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26757                 }
26758                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26759                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26761                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26762                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26763         }
26764         return NDR_ERR_SUCCESS;
26765 }
26766
26767 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26768 {
26769         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26770         ndr->depth++;
26771         if (flags & NDR_SET_VALUES) {
26772                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26773         }
26774         if (flags & NDR_IN) {
26775                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26776                 ndr->depth++;
26777                 ndr_print_ptr(ndr, "handle", r->in.handle);
26778                 ndr->depth++;
26779                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26780                 ndr->depth--;
26781                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26782                 ndr->depth++;
26783                 if (r->in.architecture) {
26784                         ndr_print_string(ndr, "architecture", r->in.architecture);
26785                 }
26786                 ndr->depth--;
26787                 ndr_print_uint32(ndr, "level", r->in.level);
26788                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26789                 ndr->depth++;
26790                 if (r->in.buffer) {
26791                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26792                 }
26793                 ndr->depth--;
26794                 ndr_print_uint32(ndr, "offered", r->in.offered);
26795                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26796                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26797                 ndr->depth--;
26798         }
26799         if (flags & NDR_OUT) {
26800                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26801                 ndr->depth++;
26802                 ndr_print_ptr(ndr, "info", r->out.info);
26803                 ndr->depth++;
26804                 if (r->out.info) {
26805                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26806                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26807                 }
26808                 ndr->depth--;
26809                 ndr_print_ptr(ndr, "needed", r->out.needed);
26810                 ndr->depth++;
26811                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26812                 ndr->depth--;
26813                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26814                 ndr->depth++;
26815                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26816                 ndr->depth--;
26817                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26818                 ndr->depth++;
26819                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26820                 ndr->depth--;
26821                 ndr_print_WERROR(ndr, "result", r->out.result);
26822                 ndr->depth--;
26823         }
26824         ndr->depth--;
26825 }
26826
26827 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26828 {
26829         if (flags & NDR_IN) {
26830         }
26831         if (flags & NDR_OUT) {
26832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26833         }
26834         return NDR_ERR_SUCCESS;
26835 }
26836
26837 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26838 {
26839         if (flags & NDR_IN) {
26840         }
26841         if (flags & NDR_OUT) {
26842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26843         }
26844         return NDR_ERR_SUCCESS;
26845 }
26846
26847 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26848 {
26849         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26850         ndr->depth++;
26851         if (flags & NDR_SET_VALUES) {
26852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26853         }
26854         if (flags & NDR_IN) {
26855                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26856                 ndr->depth++;
26857                 ndr->depth--;
26858         }
26859         if (flags & NDR_OUT) {
26860                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26861                 ndr->depth++;
26862                 ndr_print_WERROR(ndr, "result", r->out.result);
26863                 ndr->depth--;
26864         }
26865         ndr->depth--;
26866 }
26867
26868 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26869 {
26870         if (flags & NDR_IN) {
26871         }
26872         if (flags & NDR_OUT) {
26873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26874         }
26875         return NDR_ERR_SUCCESS;
26876 }
26877
26878 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26879 {
26880         if (flags & NDR_IN) {
26881         }
26882         if (flags & NDR_OUT) {
26883                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26884         }
26885         return NDR_ERR_SUCCESS;
26886 }
26887
26888 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26889 {
26890         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26891         ndr->depth++;
26892         if (flags & NDR_SET_VALUES) {
26893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26894         }
26895         if (flags & NDR_IN) {
26896                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26897                 ndr->depth++;
26898                 ndr->depth--;
26899         }
26900         if (flags & NDR_OUT) {
26901                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26902                 ndr->depth++;
26903                 ndr_print_WERROR(ndr, "result", r->out.result);
26904                 ndr->depth--;
26905         }
26906         ndr->depth--;
26907 }
26908
26909 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26910 {
26911         if (flags & NDR_IN) {
26912                 if (r->in.handle == NULL) {
26913                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26914                 }
26915                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26916         }
26917         if (flags & NDR_OUT) {
26918                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26919         }
26920         return NDR_ERR_SUCCESS;
26921 }
26922
26923 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26924 {
26925         TALLOC_CTX *_mem_save_handle_0;
26926         if (flags & NDR_IN) {
26927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26928                         NDR_PULL_ALLOC(ndr, r->in.handle);
26929                 }
26930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26934         }
26935         if (flags & NDR_OUT) {
26936                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26937         }
26938         return NDR_ERR_SUCCESS;
26939 }
26940
26941 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26942 {
26943         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26944         ndr->depth++;
26945         if (flags & NDR_SET_VALUES) {
26946                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26947         }
26948         if (flags & NDR_IN) {
26949                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26950                 ndr->depth++;
26951                 ndr_print_ptr(ndr, "handle", r->in.handle);
26952                 ndr->depth++;
26953                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26954                 ndr->depth--;
26955                 ndr->depth--;
26956         }
26957         if (flags & NDR_OUT) {
26958                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26959                 ndr->depth++;
26960                 ndr_print_WERROR(ndr, "result", r->out.result);
26961                 ndr->depth--;
26962         }
26963         ndr->depth--;
26964 }
26965
26966 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26967 {
26968         if (flags & NDR_IN) {
26969         }
26970         if (flags & NDR_OUT) {
26971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26972         }
26973         return NDR_ERR_SUCCESS;
26974 }
26975
26976 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26977 {
26978         if (flags & NDR_IN) {
26979         }
26980         if (flags & NDR_OUT) {
26981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26982         }
26983         return NDR_ERR_SUCCESS;
26984 }
26985
26986 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26987 {
26988         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26989         ndr->depth++;
26990         if (flags & NDR_SET_VALUES) {
26991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26992         }
26993         if (flags & NDR_IN) {
26994                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26995                 ndr->depth++;
26996                 ndr->depth--;
26997         }
26998         if (flags & NDR_OUT) {
26999                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
27000                 ndr->depth++;
27001                 ndr_print_WERROR(ndr, "result", r->out.result);
27002                 ndr->depth--;
27003         }
27004         ndr->depth--;
27005 }
27006
27007 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
27008 {
27009         if (flags & NDR_IN) {
27010                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
27011                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27012                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
27013                 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));
27014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27015                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
27017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
27018                 if (r->in.buffer) {
27019                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
27020                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
27021                 }
27022         }
27023         if (flags & NDR_OUT) {
27024                 if (r->out.handle == NULL) {
27025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27026                 }
27027                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27028                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27029         }
27030         return NDR_ERR_SUCCESS;
27031 }
27032
27033 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
27034 {
27035         uint32_t _ptr_buffer;
27036         TALLOC_CTX *_mem_save_buffer_0;
27037         TALLOC_CTX *_mem_save_handle_0;
27038         if (flags & NDR_IN) {
27039                 ZERO_STRUCT(r->out);
27040
27041                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
27042                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
27043                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
27044                         return 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));
27045                 }
27046                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
27047                 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));
27048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27049                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
27050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
27051                 if (r->in.bufsize > 512) {
27052                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
27053                 }
27054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
27055                 if (_ptr_buffer) {
27056                         NDR_PULL_ALLOC(ndr, r->in.buffer);
27057                 } else {
27058                         r->in.buffer = NULL;
27059                 }
27060                 if (r->in.buffer) {
27061                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27062                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
27063                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27064                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27065                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
27067                 }
27068                 NDR_PULL_ALLOC(ndr, r->out.handle);
27069                 ZERO_STRUCTP(r->out.handle);
27070                 if (r->in.buffer) {
27071                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
27072                 }
27073         }
27074         if (flags & NDR_OUT) {
27075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27076                         NDR_PULL_ALLOC(ndr, r->out.handle);
27077                 }
27078                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27079                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27080                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27081                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27082                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27083         }
27084         return NDR_ERR_SUCCESS;
27085 }
27086
27087 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
27088 {
27089         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
27090         ndr->depth++;
27091         if (flags & NDR_SET_VALUES) {
27092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27093         }
27094         if (flags & NDR_IN) {
27095                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
27096                 ndr->depth++;
27097                 ndr_print_string(ndr, "server_name", r->in.server_name);
27098                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27099                 ndr_print_winreg_Type(ndr, "type", r->in.type);
27100                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
27101                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27102                 ndr->depth++;
27103                 if (r->in.buffer) {
27104                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
27105                 }
27106                 ndr->depth--;
27107                 ndr->depth--;
27108         }
27109         if (flags & NDR_OUT) {
27110                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
27111                 ndr->depth++;
27112                 ndr_print_ptr(ndr, "handle", r->out.handle);
27113                 ndr->depth++;
27114                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27115                 ndr->depth--;
27116                 ndr_print_WERROR(ndr, "result", r->out.result);
27117                 ndr->depth--;
27118         }
27119         ndr->depth--;
27120 }
27121
27122 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
27123 {
27124         if (flags & NDR_IN) {
27125                 if (r->in.handle == NULL) {
27126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27127                 }
27128                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27129                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
27131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
27132                 if (r->in.buffer) {
27133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
27134                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
27135                 }
27136         }
27137         if (flags & NDR_OUT) {
27138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27139         }
27140         return NDR_ERR_SUCCESS;
27141 }
27142
27143 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
27144 {
27145         uint32_t _ptr_buffer;
27146         TALLOC_CTX *_mem_save_handle_0;
27147         TALLOC_CTX *_mem_save_buffer_0;
27148         if (flags & NDR_IN) {
27149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27150                         NDR_PULL_ALLOC(ndr, r->in.handle);
27151                 }
27152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27156                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
27158                 if (r->in.bufsize > 512) {
27159                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
27160                 }
27161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
27162                 if (_ptr_buffer) {
27163                         NDR_PULL_ALLOC(ndr, r->in.buffer);
27164                 } else {
27165                         r->in.buffer = NULL;
27166                 }
27167                 if (r->in.buffer) {
27168                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
27169                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
27170                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
27171                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
27172                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
27173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
27174                 }
27175                 if (r->in.buffer) {
27176                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
27177                 }
27178         }
27179         if (flags & NDR_OUT) {
27180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27181         }
27182         return NDR_ERR_SUCCESS;
27183 }
27184
27185 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
27186 {
27187         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
27188         ndr->depth++;
27189         if (flags & NDR_SET_VALUES) {
27190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27191         }
27192         if (flags & NDR_IN) {
27193                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
27194                 ndr->depth++;
27195                 ndr_print_ptr(ndr, "handle", r->in.handle);
27196                 ndr->depth++;
27197                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27198                 ndr->depth--;
27199                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27200                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
27201                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
27202                 ndr->depth++;
27203                 if (r->in.buffer) {
27204                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
27205                 }
27206                 ndr->depth--;
27207                 ndr->depth--;
27208         }
27209         if (flags & NDR_OUT) {
27210                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
27211                 ndr->depth++;
27212                 ndr_print_WERROR(ndr, "result", r->out.result);
27213                 ndr->depth--;
27214         }
27215         ndr->depth--;
27216 }
27217
27218 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
27219 {
27220         if (flags & NDR_IN) {
27221                 if (r->in.handle == NULL) {
27222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27223                 }
27224                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27225         }
27226         if (flags & NDR_OUT) {
27227                 if (r->out.handle == NULL) {
27228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27229                 }
27230                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27232         }
27233         return NDR_ERR_SUCCESS;
27234 }
27235
27236 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
27237 {
27238         TALLOC_CTX *_mem_save_handle_0;
27239         if (flags & NDR_IN) {
27240                 ZERO_STRUCT(r->out);
27241
27242                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27243                         NDR_PULL_ALLOC(ndr, r->in.handle);
27244                 }
27245                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27246                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27247                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27248                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27249                 NDR_PULL_ALLOC(ndr, r->out.handle);
27250                 *r->out.handle = *r->in.handle;
27251         }
27252         if (flags & NDR_OUT) {
27253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27254                         NDR_PULL_ALLOC(ndr, r->out.handle);
27255                 }
27256                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27257                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27258                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27260                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27261         }
27262         return NDR_ERR_SUCCESS;
27263 }
27264
27265 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
27266 {
27267         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
27268         ndr->depth++;
27269         if (flags & NDR_SET_VALUES) {
27270                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27271         }
27272         if (flags & NDR_IN) {
27273                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
27274                 ndr->depth++;
27275                 ndr_print_ptr(ndr, "handle", r->in.handle);
27276                 ndr->depth++;
27277                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27278                 ndr->depth--;
27279                 ndr->depth--;
27280         }
27281         if (flags & NDR_OUT) {
27282                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
27283                 ndr->depth++;
27284                 ndr_print_ptr(ndr, "handle", r->out.handle);
27285                 ndr->depth++;
27286                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27287                 ndr->depth--;
27288                 ndr_print_WERROR(ndr, "result", r->out.result);
27289                 ndr->depth--;
27290         }
27291         ndr->depth--;
27292 }
27293
27294 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
27295 {
27296         if (flags & NDR_IN) {
27297         }
27298         if (flags & NDR_OUT) {
27299                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27300         }
27301         return NDR_ERR_SUCCESS;
27302 }
27303
27304 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
27305 {
27306         if (flags & NDR_IN) {
27307         }
27308         if (flags & NDR_OUT) {
27309                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27310         }
27311         return NDR_ERR_SUCCESS;
27312 }
27313
27314 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
27315 {
27316         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
27317         ndr->depth++;
27318         if (flags & NDR_SET_VALUES) {
27319                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27320         }
27321         if (flags & NDR_IN) {
27322                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
27323                 ndr->depth++;
27324                 ndr->depth--;
27325         }
27326         if (flags & NDR_OUT) {
27327                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
27328                 ndr->depth++;
27329                 ndr_print_WERROR(ndr, "result", r->out.result);
27330                 ndr->depth--;
27331         }
27332         ndr->depth--;
27333 }
27334
27335 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27336 {
27337         if (flags & NDR_IN) {
27338         }
27339         if (flags & NDR_OUT) {
27340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27341         }
27342         return NDR_ERR_SUCCESS;
27343 }
27344
27345 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27346 {
27347         if (flags & NDR_IN) {
27348         }
27349         if (flags & NDR_OUT) {
27350                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27351         }
27352         return NDR_ERR_SUCCESS;
27353 }
27354
27355 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
27356 {
27357         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
27358         ndr->depth++;
27359         if (flags & NDR_SET_VALUES) {
27360                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27361         }
27362         if (flags & NDR_IN) {
27363                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
27364                 ndr->depth++;
27365                 ndr->depth--;
27366         }
27367         if (flags & NDR_OUT) {
27368                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
27369                 ndr->depth++;
27370                 ndr_print_WERROR(ndr, "result", r->out.result);
27371                 ndr->depth--;
27372         }
27373         ndr->depth--;
27374 }
27375
27376 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
27377 {
27378         if (flags & NDR_IN) {
27379         }
27380         if (flags & NDR_OUT) {
27381                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27382         }
27383         return NDR_ERR_SUCCESS;
27384 }
27385
27386 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
27387 {
27388         if (flags & NDR_IN) {
27389         }
27390         if (flags & NDR_OUT) {
27391                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27392         }
27393         return NDR_ERR_SUCCESS;
27394 }
27395
27396 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
27397 {
27398         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
27399         ndr->depth++;
27400         if (flags & NDR_SET_VALUES) {
27401                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27402         }
27403         if (flags & NDR_IN) {
27404                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
27405                 ndr->depth++;
27406                 ndr->depth--;
27407         }
27408         if (flags & NDR_OUT) {
27409                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
27410                 ndr->depth++;
27411                 ndr_print_WERROR(ndr, "result", r->out.result);
27412                 ndr->depth--;
27413         }
27414         ndr->depth--;
27415 }
27416
27417 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
27418 {
27419         if (flags & NDR_IN) {
27420         }
27421         if (flags & NDR_OUT) {
27422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27423         }
27424         return NDR_ERR_SUCCESS;
27425 }
27426
27427 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
27428 {
27429         if (flags & NDR_IN) {
27430         }
27431         if (flags & NDR_OUT) {
27432                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27433         }
27434         return NDR_ERR_SUCCESS;
27435 }
27436
27437 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
27438 {
27439         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
27440         ndr->depth++;
27441         if (flags & NDR_SET_VALUES) {
27442                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27443         }
27444         if (flags & NDR_IN) {
27445                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
27446                 ndr->depth++;
27447                 ndr->depth--;
27448         }
27449         if (flags & NDR_OUT) {
27450                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
27451                 ndr->depth++;
27452                 ndr_print_WERROR(ndr, "result", r->out.result);
27453                 ndr->depth--;
27454         }
27455         ndr->depth--;
27456 }
27457
27458 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27459 {
27460         if (flags & NDR_IN) {
27461                 if (r->in.handle == NULL) {
27462                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27463                 }
27464                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27465                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
27467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
27468                 if (r->in.local_machine) {
27469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
27472                         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));
27473                 }
27474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
27475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
27476                 if (r->in.notify_options) {
27477                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27478                 }
27479         }
27480         if (flags & NDR_OUT) {
27481                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27482         }
27483         return NDR_ERR_SUCCESS;
27484 }
27485
27486 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27487 {
27488         uint32_t _ptr_local_machine;
27489         uint32_t _ptr_notify_options;
27490         TALLOC_CTX *_mem_save_handle_0;
27491         TALLOC_CTX *_mem_save_local_machine_0;
27492         TALLOC_CTX *_mem_save_notify_options_0;
27493         if (flags & NDR_IN) {
27494                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27495                         NDR_PULL_ALLOC(ndr, r->in.handle);
27496                 }
27497                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27498                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27499                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27501                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27502                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
27503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
27504                 if (_ptr_local_machine) {
27505                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
27506                 } else {
27507                         r->in.local_machine = NULL;
27508                 }
27509                 if (r->in.local_machine) {
27510                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
27511                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
27512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
27513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
27514                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
27515                                 return 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));
27516                         }
27517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
27518                         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));
27519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
27520                 }
27521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
27522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
27523                 if (_ptr_notify_options) {
27524                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
27525                 } else {
27526                         r->in.notify_options = NULL;
27527                 }
27528                 if (r->in.notify_options) {
27529                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
27531                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
27532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
27533                 }
27534         }
27535         if (flags & NDR_OUT) {
27536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27537         }
27538         return NDR_ERR_SUCCESS;
27539 }
27540
27541 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
27542 {
27543         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27544         ndr->depth++;
27545         if (flags & NDR_SET_VALUES) {
27546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27547         }
27548         if (flags & NDR_IN) {
27549                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27550                 ndr->depth++;
27551                 ndr_print_ptr(ndr, "handle", r->in.handle);
27552                 ndr->depth++;
27553                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27554                 ndr->depth--;
27555                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27556                 ndr_print_uint32(ndr, "options", r->in.options);
27557                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27558                 ndr->depth++;
27559                 if (r->in.local_machine) {
27560                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27561                 }
27562                 ndr->depth--;
27563                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27564                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27565                 ndr->depth++;
27566                 if (r->in.notify_options) {
27567                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27568                 }
27569                 ndr->depth--;
27570                 ndr->depth--;
27571         }
27572         if (flags & NDR_OUT) {
27573                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27574                 ndr->depth++;
27575                 ndr_print_WERROR(ndr, "result", r->out.result);
27576                 ndr->depth--;
27577         }
27578         ndr->depth--;
27579 }
27580
27581 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27582 {
27583         if (flags & NDR_IN) {
27584                 if (r->in.handle == NULL) {
27585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27586                 }
27587                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27588                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27589                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27591                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27592                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27593         }
27594         if (flags & NDR_OUT) {
27595                 if (r->out.reply_result == NULL) {
27596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27597                 }
27598                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27599                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27600         }
27601         return NDR_ERR_SUCCESS;
27602 }
27603
27604 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27605 {
27606         TALLOC_CTX *_mem_save_handle_0;
27607         TALLOC_CTX *_mem_save_reply_result_0;
27608         if (flags & NDR_IN) {
27609                 ZERO_STRUCT(r->out);
27610
27611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27612                         NDR_PULL_ALLOC(ndr, r->in.handle);
27613                 }
27614                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27615                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27616                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27619                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27621                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27622                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27623                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27624                 ZERO_STRUCTP(r->out.reply_result);
27625         }
27626         if (flags & NDR_OUT) {
27627                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27628                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27629                 }
27630                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27631                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27632                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27633                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27634                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27635         }
27636         return NDR_ERR_SUCCESS;
27637 }
27638
27639 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27640 {
27641         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27642         ndr->depth++;
27643         if (flags & NDR_SET_VALUES) {
27644                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27645         }
27646         if (flags & NDR_IN) {
27647                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27648                 ndr->depth++;
27649                 ndr_print_ptr(ndr, "handle", r->in.handle);
27650                 ndr->depth++;
27651                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27652                 ndr->depth--;
27653                 ndr_print_uint32(ndr, "color", r->in.color);
27654                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27655                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27656                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27657                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27658                 ndr->depth--;
27659         }
27660         if (flags & NDR_OUT) {
27661                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27662                 ndr->depth++;
27663                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27664                 ndr->depth++;
27665                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27666                 ndr->depth--;
27667                 ndr_print_WERROR(ndr, "result", r->out.result);
27668                 ndr->depth--;
27669         }
27670         ndr->depth--;
27671 }
27672
27673 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27674 {
27675         if (flags & NDR_IN) {
27676                 if (r->in.handle == NULL) {
27677                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27678                 }
27679                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27682                 if (r->in.options) {
27683                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27684                 }
27685         }
27686         if (flags & NDR_OUT) {
27687                 if (r->out.info == NULL) {
27688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27689                 }
27690                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27691                 if (*r->out.info) {
27692                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27693                 }
27694                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27695         }
27696         return NDR_ERR_SUCCESS;
27697 }
27698
27699 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27700 {
27701         uint32_t _ptr_options;
27702         uint32_t _ptr_info;
27703         TALLOC_CTX *_mem_save_handle_0;
27704         TALLOC_CTX *_mem_save_options_0;
27705         TALLOC_CTX *_mem_save_info_0;
27706         TALLOC_CTX *_mem_save_info_1;
27707         if (flags & NDR_IN) {
27708                 ZERO_STRUCT(r->out);
27709
27710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27711                         NDR_PULL_ALLOC(ndr, r->in.handle);
27712                 }
27713                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27714                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27715                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27719                 if (_ptr_options) {
27720                         NDR_PULL_ALLOC(ndr, r->in.options);
27721                 } else {
27722                         r->in.options = NULL;
27723                 }
27724                 if (r->in.options) {
27725                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27727                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27729                 }
27730                 NDR_PULL_ALLOC(ndr, r->out.info);
27731                 ZERO_STRUCTP(r->out.info);
27732         }
27733         if (flags & NDR_OUT) {
27734                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27735                         NDR_PULL_ALLOC(ndr, r->out.info);
27736                 }
27737                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27738                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27740                 if (_ptr_info) {
27741                         NDR_PULL_ALLOC(ndr, *r->out.info);
27742                 } else {
27743                         *r->out.info = NULL;
27744                 }
27745                 if (*r->out.info) {
27746                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27747                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27748                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27750                 }
27751                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27753         }
27754         return NDR_ERR_SUCCESS;
27755 }
27756
27757 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27758 {
27759         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27760         ndr->depth++;
27761         if (flags & NDR_SET_VALUES) {
27762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27763         }
27764         if (flags & NDR_IN) {
27765                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27766                 ndr->depth++;
27767                 ndr_print_ptr(ndr, "handle", r->in.handle);
27768                 ndr->depth++;
27769                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27770                 ndr->depth--;
27771                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27772                 ndr_print_ptr(ndr, "options", r->in.options);
27773                 ndr->depth++;
27774                 if (r->in.options) {
27775                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27776                 }
27777                 ndr->depth--;
27778                 ndr->depth--;
27779         }
27780         if (flags & NDR_OUT) {
27781                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27782                 ndr->depth++;
27783                 ndr_print_ptr(ndr, "info", r->out.info);
27784                 ndr->depth++;
27785                 ndr_print_ptr(ndr, "info", *r->out.info);
27786                 ndr->depth++;
27787                 if (*r->out.info) {
27788                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27789                 }
27790                 ndr->depth--;
27791                 ndr->depth--;
27792                 ndr_print_WERROR(ndr, "result", r->out.result);
27793                 ndr->depth--;
27794         }
27795         ndr->depth--;
27796 }
27797
27798 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27799 {
27800         if (flags & NDR_IN) {
27801         }
27802         if (flags & NDR_OUT) {
27803                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27804         }
27805         return NDR_ERR_SUCCESS;
27806 }
27807
27808 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27809 {
27810         if (flags & NDR_IN) {
27811         }
27812         if (flags & NDR_OUT) {
27813                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27814         }
27815         return NDR_ERR_SUCCESS;
27816 }
27817
27818 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27819 {
27820         ndr_print_struct(ndr, name, "spoolss_44");
27821         ndr->depth++;
27822         if (flags & NDR_SET_VALUES) {
27823                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27824         }
27825         if (flags & NDR_IN) {
27826                 ndr_print_struct(ndr, "in", "spoolss_44");
27827                 ndr->depth++;
27828                 ndr->depth--;
27829         }
27830         if (flags & NDR_OUT) {
27831                 ndr_print_struct(ndr, "out", "spoolss_44");
27832                 ndr->depth++;
27833                 ndr_print_WERROR(ndr, "result", r->out.result);
27834                 ndr->depth--;
27835         }
27836         ndr->depth--;
27837 }
27838
27839 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27840 {
27841         if (flags & NDR_IN) {
27842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27843                 if (r->in.printername) {
27844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27848                 }
27849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27850                 if (r->in.datatype) {
27851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27855                 }
27856                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27857                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27859                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27860                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27861         }
27862         if (flags & NDR_OUT) {
27863                 if (r->out.handle == NULL) {
27864                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27865                 }
27866                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27867                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27868         }
27869         return NDR_ERR_SUCCESS;
27870 }
27871
27872 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27873 {
27874         uint32_t _ptr_printername;
27875         uint32_t _ptr_datatype;
27876         TALLOC_CTX *_mem_save_printername_0;
27877         TALLOC_CTX *_mem_save_datatype_0;
27878         TALLOC_CTX *_mem_save_handle_0;
27879         if (flags & NDR_IN) {
27880                 ZERO_STRUCT(r->out);
27881
27882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27883                 if (_ptr_printername) {
27884                         NDR_PULL_ALLOC(ndr, r->in.printername);
27885                 } else {
27886                         r->in.printername = NULL;
27887                 }
27888                 if (r->in.printername) {
27889                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27890                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27893                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27894                                 return 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));
27895                         }
27896                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27899                 }
27900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27901                 if (_ptr_datatype) {
27902                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27903                 } else {
27904                         r->in.datatype = NULL;
27905                 }
27906                 if (r->in.datatype) {
27907                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27908                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27911                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27912                                 return 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));
27913                         }
27914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27917                 }
27918                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27919                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27921                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27922                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27923                 NDR_PULL_ALLOC(ndr, r->out.handle);
27924                 ZERO_STRUCTP(r->out.handle);
27925         }
27926         if (flags & NDR_OUT) {
27927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27928                         NDR_PULL_ALLOC(ndr, r->out.handle);
27929                 }
27930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27931                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27935         }
27936         return NDR_ERR_SUCCESS;
27937 }
27938
27939 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27940 {
27941         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27942         ndr->depth++;
27943         if (flags & NDR_SET_VALUES) {
27944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27945         }
27946         if (flags & NDR_IN) {
27947                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27948                 ndr->depth++;
27949                 ndr_print_ptr(ndr, "printername", r->in.printername);
27950                 ndr->depth++;
27951                 if (r->in.printername) {
27952                         ndr_print_string(ndr, "printername", r->in.printername);
27953                 }
27954                 ndr->depth--;
27955                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27956                 ndr->depth++;
27957                 if (r->in.datatype) {
27958                         ndr_print_string(ndr, "datatype", r->in.datatype);
27959                 }
27960                 ndr->depth--;
27961                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27962                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27963                 ndr_print_uint32(ndr, "level", r->in.level);
27964                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27965                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27966                 ndr->depth--;
27967         }
27968         if (flags & NDR_OUT) {
27969                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27970                 ndr->depth++;
27971                 ndr_print_ptr(ndr, "handle", r->out.handle);
27972                 ndr->depth++;
27973                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27974                 ndr->depth--;
27975                 ndr_print_WERROR(ndr, "result", r->out.result);
27976                 ndr->depth--;
27977         }
27978         ndr->depth--;
27979 }
27980
27981 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27982 {
27983         if (flags & NDR_IN) {
27984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27985                 if (r->in.server) {
27986                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27989                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27990                 }
27991                 if (r->in.info_ctr == NULL) {
27992                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27993                 }
27994                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27995                 if (r->in.devmode_ctr == NULL) {
27996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27997                 }
27998                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27999                 if (r->in.secdesc_ctr == NULL) {
28000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28001                 }
28002                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
28003                 if (r->in.userlevel_ctr == NULL) {
28004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28005                 }
28006                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
28007         }
28008         if (flags & NDR_OUT) {
28009                 if (r->out.handle == NULL) {
28010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28011                 }
28012                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
28013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28014         }
28015         return NDR_ERR_SUCCESS;
28016 }
28017
28018 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
28019 {
28020         uint32_t _ptr_server;
28021         TALLOC_CTX *_mem_save_server_0;
28022         TALLOC_CTX *_mem_save_info_ctr_0;
28023         TALLOC_CTX *_mem_save_devmode_ctr_0;
28024         TALLOC_CTX *_mem_save_secdesc_ctr_0;
28025         TALLOC_CTX *_mem_save_userlevel_ctr_0;
28026         TALLOC_CTX *_mem_save_handle_0;
28027         if (flags & NDR_IN) {
28028                 ZERO_STRUCT(r->out);
28029
28030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28031                 if (_ptr_server) {
28032                         NDR_PULL_ALLOC(ndr, r->in.server);
28033                 } else {
28034                         r->in.server = NULL;
28035                 }
28036                 if (r->in.server) {
28037                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28041                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28042                                 return 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));
28043                         }
28044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28045                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28047                 }
28048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28049                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
28050                 }
28051                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28052                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
28053                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
28054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28056                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
28057                 }
28058                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
28060                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
28061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28062                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28063                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
28064                 }
28065                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28066                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
28067                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
28068                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28070                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
28071                 }
28072                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
28073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
28074                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
28075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
28076                 NDR_PULL_ALLOC(ndr, r->out.handle);
28077                 ZERO_STRUCTP(r->out.handle);
28078         }
28079         if (flags & NDR_OUT) {
28080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28081                         NDR_PULL_ALLOC(ndr, r->out.handle);
28082                 }
28083                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28084                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
28085                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
28086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28088         }
28089         return NDR_ERR_SUCCESS;
28090 }
28091
28092 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
28093 {
28094         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
28095         ndr->depth++;
28096         if (flags & NDR_SET_VALUES) {
28097                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28098         }
28099         if (flags & NDR_IN) {
28100                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
28101                 ndr->depth++;
28102                 ndr_print_ptr(ndr, "server", r->in.server);
28103                 ndr->depth++;
28104                 if (r->in.server) {
28105                         ndr_print_string(ndr, "server", r->in.server);
28106                 }
28107                 ndr->depth--;
28108                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
28109                 ndr->depth++;
28110                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
28111                 ndr->depth--;
28112                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
28113                 ndr->depth++;
28114                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
28115                 ndr->depth--;
28116                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28117                 ndr->depth++;
28118                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
28119                 ndr->depth--;
28120                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28121                 ndr->depth++;
28122                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
28123                 ndr->depth--;
28124                 ndr->depth--;
28125         }
28126         if (flags & NDR_OUT) {
28127                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
28128                 ndr->depth++;
28129                 ndr_print_ptr(ndr, "handle", r->out.handle);
28130                 ndr->depth++;
28131                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
28132                 ndr->depth--;
28133                 ndr_print_WERROR(ndr, "result", r->out.result);
28134                 ndr->depth--;
28135         }
28136         ndr->depth--;
28137 }
28138
28139 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
28140 {
28141         if (flags & NDR_IN) {
28142         }
28143         if (flags & NDR_OUT) {
28144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28145         }
28146         return NDR_ERR_SUCCESS;
28147 }
28148
28149 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
28150 {
28151         if (flags & NDR_IN) {
28152         }
28153         if (flags & NDR_OUT) {
28154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28155         }
28156         return NDR_ERR_SUCCESS;
28157 }
28158
28159 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
28160 {
28161         ndr_print_struct(ndr, name, "spoolss_47");
28162         ndr->depth++;
28163         if (flags & NDR_SET_VALUES) {
28164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28165         }
28166         if (flags & NDR_IN) {
28167                 ndr_print_struct(ndr, "in", "spoolss_47");
28168                 ndr->depth++;
28169                 ndr->depth--;
28170         }
28171         if (flags & NDR_OUT) {
28172                 ndr_print_struct(ndr, "out", "spoolss_47");
28173                 ndr->depth++;
28174                 ndr_print_WERROR(ndr, "result", r->out.result);
28175                 ndr->depth--;
28176         }
28177         ndr->depth--;
28178 }
28179
28180 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
28181 {
28182         if (flags & NDR_IN) {
28183                 if (r->in.handle == NULL) {
28184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28185                 }
28186                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
28188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
28189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
28190         }
28191         if (flags & NDR_OUT) {
28192                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
28193                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
28194                 if (r->out.value_needed == NULL) {
28195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28196                 }
28197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
28198                 if (r->out.type == NULL) {
28199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28200                 }
28201                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28202                 {
28203                         uint32_t _flags_save_uint8 = ndr->flags;
28204                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28205                         if (r->out.data == NULL) {
28206                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28207                         }
28208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
28209                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
28210                         ndr->flags = _flags_save_uint8;
28211                 }
28212                 if (r->out.data_needed == NULL) {
28213                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28214                 }
28215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
28216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28217         }
28218         return NDR_ERR_SUCCESS;
28219 }
28220
28221 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
28222 {
28223         TALLOC_CTX *_mem_save_handle_0;
28224         TALLOC_CTX *_mem_save_value_needed_0;
28225         TALLOC_CTX *_mem_save_type_0;
28226         TALLOC_CTX *_mem_save_data_needed_0;
28227         if (flags & NDR_IN) {
28228                 ZERO_STRUCT(r->out);
28229
28230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28231                         NDR_PULL_ALLOC(ndr, r->in.handle);
28232                 }
28233                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28235                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
28238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
28239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
28240                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
28241                 ZERO_STRUCTP(r->out.value_needed);
28242                 NDR_PULL_ALLOC(ndr, r->out.type);
28243                 ZERO_STRUCTP(r->out.type);
28244                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
28245                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
28246                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
28247                 ZERO_STRUCTP(r->out.data_needed);
28248         }
28249         if (flags & NDR_OUT) {
28250                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
28251                 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));
28252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28253                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
28254                 }
28255                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28256                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
28257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
28258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
28259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28260                         NDR_PULL_ALLOC(ndr, r->out.type);
28261                 }
28262                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28263                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28264                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28265                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28266                 {
28267                         uint32_t _flags_save_uint8 = ndr->flags;
28268                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
28269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
28270                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28271                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
28272                         }
28273                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
28274                         ndr->flags = _flags_save_uint8;
28275                 }
28276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28277                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
28278                 }
28279                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28280                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
28281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
28282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
28283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28284                 if (r->out.value_name) {
28285                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
28286                 }
28287                 if (r->out.data) {
28288                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
28289                 }
28290         }
28291         return NDR_ERR_SUCCESS;
28292 }
28293
28294 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
28295 {
28296         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
28297         ndr->depth++;
28298         if (flags & NDR_SET_VALUES) {
28299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28300         }
28301         if (flags & NDR_IN) {
28302                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
28303                 ndr->depth++;
28304                 ndr_print_ptr(ndr, "handle", r->in.handle);
28305                 ndr->depth++;
28306                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28307                 ndr->depth--;
28308                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
28309                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
28310                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
28311                 ndr->depth--;
28312         }
28313         if (flags & NDR_OUT) {
28314                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
28315                 ndr->depth++;
28316                 ndr_print_string(ndr, "value_name", r->out.value_name);
28317                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
28318                 ndr->depth++;
28319                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
28320                 ndr->depth--;
28321                 ndr_print_ptr(ndr, "type", r->out.type);
28322                 ndr->depth++;
28323                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28324                 ndr->depth--;
28325                 ndr_print_ptr(ndr, "data", r->out.data);
28326                 ndr->depth++;
28327                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
28328                 ndr->depth--;
28329                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
28330                 ndr->depth++;
28331                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
28332                 ndr->depth--;
28333                 ndr_print_WERROR(ndr, "result", r->out.result);
28334                 ndr->depth--;
28335         }
28336         ndr->depth--;
28337 }
28338
28339 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
28340 {
28341         if (flags & NDR_IN) {
28342                 if (r->in.handle == NULL) {
28343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28344                 }
28345                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28346                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28347                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28348                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28349                 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));
28350         }
28351         if (flags & NDR_OUT) {
28352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28353         }
28354         return NDR_ERR_SUCCESS;
28355 }
28356
28357 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
28358 {
28359         TALLOC_CTX *_mem_save_handle_0;
28360         if (flags & NDR_IN) {
28361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28362                         NDR_PULL_ALLOC(ndr, r->in.handle);
28363                 }
28364                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28365                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28368                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28369                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28370                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28371                         return 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));
28372                 }
28373                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28374                 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));
28375         }
28376         if (flags & NDR_OUT) {
28377                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28378         }
28379         return NDR_ERR_SUCCESS;
28380 }
28381
28382 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
28383 {
28384         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
28385         ndr->depth++;
28386         if (flags & NDR_SET_VALUES) {
28387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28388         }
28389         if (flags & NDR_IN) {
28390                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
28391                 ndr->depth++;
28392                 ndr_print_ptr(ndr, "handle", r->in.handle);
28393                 ndr->depth++;
28394                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28395                 ndr->depth--;
28396                 ndr_print_string(ndr, "value_name", r->in.value_name);
28397                 ndr->depth--;
28398         }
28399         if (flags & NDR_OUT) {
28400                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
28401                 ndr->depth++;
28402                 ndr_print_WERROR(ndr, "result", r->out.result);
28403                 ndr->depth--;
28404         }
28405         ndr->depth--;
28406 }
28407
28408 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
28409 {
28410         if (flags & NDR_IN) {
28411         }
28412         if (flags & NDR_OUT) {
28413                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28414         }
28415         return NDR_ERR_SUCCESS;
28416 }
28417
28418 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
28419 {
28420         if (flags & NDR_IN) {
28421         }
28422         if (flags & NDR_OUT) {
28423                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28424         }
28425         return NDR_ERR_SUCCESS;
28426 }
28427
28428 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
28429 {
28430         ndr_print_struct(ndr, name, "spoolss_4a");
28431         ndr->depth++;
28432         if (flags & NDR_SET_VALUES) {
28433                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28434         }
28435         if (flags & NDR_IN) {
28436                 ndr_print_struct(ndr, "in", "spoolss_4a");
28437                 ndr->depth++;
28438                 ndr->depth--;
28439         }
28440         if (flags & NDR_OUT) {
28441                 ndr_print_struct(ndr, "out", "spoolss_4a");
28442                 ndr->depth++;
28443                 ndr_print_WERROR(ndr, "result", r->out.result);
28444                 ndr->depth--;
28445         }
28446         ndr->depth--;
28447 }
28448
28449 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
28450 {
28451         if (flags & NDR_IN) {
28452         }
28453         if (flags & NDR_OUT) {
28454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28455         }
28456         return NDR_ERR_SUCCESS;
28457 }
28458
28459 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
28460 {
28461         if (flags & NDR_IN) {
28462         }
28463         if (flags & NDR_OUT) {
28464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28465         }
28466         return NDR_ERR_SUCCESS;
28467 }
28468
28469 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
28470 {
28471         ndr_print_struct(ndr, name, "spoolss_4b");
28472         ndr->depth++;
28473         if (flags & NDR_SET_VALUES) {
28474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28475         }
28476         if (flags & NDR_IN) {
28477                 ndr_print_struct(ndr, "in", "spoolss_4b");
28478                 ndr->depth++;
28479                 ndr->depth--;
28480         }
28481         if (flags & NDR_OUT) {
28482                 ndr_print_struct(ndr, "out", "spoolss_4b");
28483                 ndr->depth++;
28484                 ndr_print_WERROR(ndr, "result", r->out.result);
28485                 ndr->depth--;
28486         }
28487         ndr->depth--;
28488 }
28489
28490 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
28491 {
28492         if (flags & NDR_IN) {
28493         }
28494         if (flags & NDR_OUT) {
28495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28496         }
28497         return NDR_ERR_SUCCESS;
28498 }
28499
28500 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
28501 {
28502         if (flags & NDR_IN) {
28503         }
28504         if (flags & NDR_OUT) {
28505                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28506         }
28507         return NDR_ERR_SUCCESS;
28508 }
28509
28510 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
28511 {
28512         ndr_print_struct(ndr, name, "spoolss_4c");
28513         ndr->depth++;
28514         if (flags & NDR_SET_VALUES) {
28515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28516         }
28517         if (flags & NDR_IN) {
28518                 ndr_print_struct(ndr, "in", "spoolss_4c");
28519                 ndr->depth++;
28520                 ndr->depth--;
28521         }
28522         if (flags & NDR_OUT) {
28523                 ndr_print_struct(ndr, "out", "spoolss_4c");
28524                 ndr->depth++;
28525                 ndr_print_WERROR(ndr, "result", r->out.result);
28526                 ndr->depth--;
28527         }
28528         ndr->depth--;
28529 }
28530
28531 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
28532 {
28533         if (flags & NDR_IN) {
28534                 if (r->in.handle == NULL) {
28535                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28536                 }
28537                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28538                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28539                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28540                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28541                 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));
28542                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28543                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28544                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28545                 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));
28546                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28547                 if (r->in.data == NULL) {
28548                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28549                 }
28550                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
28551                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.data, r->in.offered));
28552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28553         }
28554         if (flags & NDR_OUT) {
28555                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28556         }
28557         return NDR_ERR_SUCCESS;
28558 }
28559
28560 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28561 {
28562         TALLOC_CTX *_mem_save_handle_0;
28563         if (flags & NDR_IN) {
28564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28565                         NDR_PULL_ALLOC(ndr, r->in.handle);
28566                 }
28567                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28568                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28569                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28571                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28572                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28573                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28574                         return 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));
28575                 }
28576                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28577                 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));
28578                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28579                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28580                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28581                         return 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));
28582                 }
28583                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28584                 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));
28585                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28586                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data));
28587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28588                         NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
28589                 }
28590                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.data, ndr_get_array_size(ndr, &r->in.data)));
28591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28592                 if (r->in.data) {
28593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.data, r->in.offered));
28594                 }
28595         }
28596         if (flags & NDR_OUT) {
28597                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28598         }
28599         return NDR_ERR_SUCCESS;
28600 }
28601
28602 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28603 {
28604         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28605         ndr->depth++;
28606         if (flags & NDR_SET_VALUES) {
28607                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28608         }
28609         if (flags & NDR_IN) {
28610                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28611                 ndr->depth++;
28612                 ndr_print_ptr(ndr, "handle", r->in.handle);
28613                 ndr->depth++;
28614                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28615                 ndr->depth--;
28616                 ndr_print_string(ndr, "key_name", r->in.key_name);
28617                 ndr_print_string(ndr, "value_name", r->in.value_name);
28618                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28619                 ndr_print_ptr(ndr, "data", r->in.data);
28620                 ndr->depth++;
28621                 ndr_print_array_uint8(ndr, "data", r->in.data, r->in.offered);
28622                 ndr->depth--;
28623                 ndr_print_uint32(ndr, "offered", r->in.offered);
28624                 ndr->depth--;
28625         }
28626         if (flags & NDR_OUT) {
28627                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28628                 ndr->depth++;
28629                 ndr_print_WERROR(ndr, "result", r->out.result);
28630                 ndr->depth--;
28631         }
28632         ndr->depth--;
28633 }
28634
28635 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
28636 {
28637         if (flags & NDR_IN) {
28638                 if (r->in.handle == NULL) {
28639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28640                 }
28641                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28642                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28643                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28644                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28645                 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));
28646                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28647                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28648                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28649                 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));
28650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28651         }
28652         if (flags & NDR_OUT) {
28653                 if (r->out.type == NULL) {
28654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28655                 }
28656                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28657                 if (r->out.data == NULL) {
28658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28659                 }
28660                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
28661                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.offered));
28662                 if (r->out.needed == NULL) {
28663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28664                 }
28665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28667         }
28668         return NDR_ERR_SUCCESS;
28669 }
28670
28671 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
28672 {
28673         TALLOC_CTX *_mem_save_handle_0;
28674         TALLOC_CTX *_mem_save_type_0;
28675         TALLOC_CTX *_mem_save_needed_0;
28676         if (flags & NDR_IN) {
28677                 ZERO_STRUCT(r->out);
28678
28679                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28680                         NDR_PULL_ALLOC(ndr, r->in.handle);
28681                 }
28682                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28683                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28684                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28685                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28686                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28687                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28688                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28689                         return 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));
28690                 }
28691                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28692                 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));
28693                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28694                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28695                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28696                         return 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));
28697                 }
28698                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28699                 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));
28700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28701                 NDR_PULL_ALLOC(ndr, r->out.type);
28702                 ZERO_STRUCTP(r->out.type);
28703                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.offered);
28704                 memset(r->out.data, 0, (r->in.offered) * sizeof(*r->out.data));
28705                 NDR_PULL_ALLOC(ndr, r->out.needed);
28706                 ZERO_STRUCTP(r->out.needed);
28707         }
28708         if (flags & NDR_OUT) {
28709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28710                         NDR_PULL_ALLOC(ndr, r->out.type);
28711                 }
28712                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28713                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28714                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28716                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
28717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28718                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
28719                 }
28720                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
28721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28722                         NDR_PULL_ALLOC(ndr, r->out.needed);
28723                 }
28724                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28725                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28728                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28729                 if (r->out.data) {
28730                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.offered));
28731                 }
28732         }
28733         return NDR_ERR_SUCCESS;
28734 }
28735
28736 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28737 {
28738         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28739         ndr->depth++;
28740         if (flags & NDR_SET_VALUES) {
28741                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28742         }
28743         if (flags & NDR_IN) {
28744                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28745                 ndr->depth++;
28746                 ndr_print_ptr(ndr, "handle", r->in.handle);
28747                 ndr->depth++;
28748                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28749                 ndr->depth--;
28750                 ndr_print_string(ndr, "key_name", r->in.key_name);
28751                 ndr_print_string(ndr, "value_name", r->in.value_name);
28752                 ndr_print_uint32(ndr, "offered", r->in.offered);
28753                 ndr->depth--;
28754         }
28755         if (flags & NDR_OUT) {
28756                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28757                 ndr->depth++;
28758                 ndr_print_ptr(ndr, "type", r->out.type);
28759                 ndr->depth++;
28760                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28761                 ndr->depth--;
28762                 ndr_print_ptr(ndr, "data", r->out.data);
28763                 ndr->depth++;
28764                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.offered);
28765                 ndr->depth--;
28766                 ndr_print_ptr(ndr, "needed", r->out.needed);
28767                 ndr->depth++;
28768                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28769                 ndr->depth--;
28770                 ndr_print_WERROR(ndr, "result", r->out.result);
28771                 ndr->depth--;
28772         }
28773         ndr->depth--;
28774 }
28775
28776 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28777 {
28778         if (flags & NDR_IN) {
28779                 if (r->in.handle == NULL) {
28780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28781                 }
28782                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28783                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28784                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28785                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28786                 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));
28787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28788         }
28789         if (flags & NDR_OUT) {
28790                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28791                 if (r->out.needed == NULL) {
28792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28793                 }
28794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28795                 if (r->out.count == NULL) {
28796                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28797                 }
28798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28800         }
28801         return NDR_ERR_SUCCESS;
28802 }
28803
28804 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28805 {
28806         TALLOC_CTX *_mem_save_handle_0;
28807         TALLOC_CTX *_mem_save_needed_0;
28808         TALLOC_CTX *_mem_save_count_0;
28809         if (flags & NDR_IN) {
28810                 ZERO_STRUCT(r->out);
28811
28812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28813                         NDR_PULL_ALLOC(ndr, r->in.handle);
28814                 }
28815                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28816                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28817                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28819                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28820                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28821                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28822                         return 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));
28823                 }
28824                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28825                 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));
28826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28827                 NDR_PULL_ALLOC(ndr, r->out.needed);
28828                 ZERO_STRUCTP(r->out.needed);
28829                 NDR_PULL_ALLOC(ndr, r->out.count);
28830                 ZERO_STRUCTP(r->out.count);
28831         }
28832         if (flags & NDR_OUT) {
28833                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28835                         NDR_PULL_ALLOC(ndr, r->out.needed);
28836                 }
28837                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28838                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28842                         NDR_PULL_ALLOC(ndr, r->out.count);
28843                 }
28844                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28845                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28849         }
28850         return NDR_ERR_SUCCESS;
28851 }
28852
28853 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28854 {
28855         uint32_t cntr_info_0;
28856         if (flags & NDR_IN) {
28857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28858         }
28859         if (flags & NDR_OUT) {
28860                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28861                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28862                 }
28863                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28864                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28865                 }
28866         }
28867         return NDR_ERR_SUCCESS;
28868 }
28869
28870 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28871 {
28872         uint32_t cntr_info_0;
28873         TALLOC_CTX *_mem_save_info_0;
28874         if (flags & NDR_IN) {
28875                 ZERO_STRUCT(r->out);
28876
28877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28878         }
28879         if (flags & NDR_OUT) {
28880                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28881                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28882                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28883                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28884                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28885                 }
28886                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28887                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28888                 }
28889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28890         }
28891         return NDR_ERR_SUCCESS;
28892 }
28893
28894 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28895 {
28896         uint32_t cntr_info_2;
28897         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28898         ndr->depth++;
28899         if (flags & NDR_SET_VALUES) {
28900                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28901         }
28902         if (flags & NDR_IN) {
28903                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28904                 ndr->depth++;
28905                 ndr_print_ptr(ndr, "handle", r->in.handle);
28906                 ndr->depth++;
28907                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28908                 ndr->depth--;
28909                 ndr_print_string(ndr, "key_name", r->in.key_name);
28910                 ndr_print_uint32(ndr, "offered", r->in.offered);
28911                 ndr->depth--;
28912         }
28913         if (flags & NDR_OUT) {
28914                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28915                 ndr->depth++;
28916                 ndr_print_ptr(ndr, "count", r->out.count);
28917                 ndr->depth++;
28918                 ndr_print_uint32(ndr, "count", *r->out.count);
28919                 ndr->depth--;
28920                 ndr_print_ptr(ndr, "info", r->out.info);
28921                 ndr->depth++;
28922                 ndr_print_ptr(ndr, "info", *r->out.info);
28923                 ndr->depth++;
28924                 if (*r->out.info) {
28925                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28926                         ndr->depth++;
28927                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28928                                 char *idx_2=NULL;
28929                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28930                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28931                                         free(idx_2);
28932                                 }
28933                         }
28934                         ndr->depth--;
28935                 }
28936                 ndr->depth--;
28937                 ndr->depth--;
28938                 ndr_print_ptr(ndr, "needed", r->out.needed);
28939                 ndr->depth++;
28940                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28941                 ndr->depth--;
28942                 ndr_print_WERROR(ndr, "result", r->out.result);
28943                 ndr->depth--;
28944         }
28945         ndr->depth--;
28946 }
28947
28948 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28949 {
28950         if (flags & NDR_IN) {
28951                 if (r->in.handle == NULL) {
28952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28953                 }
28954                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28955                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28956                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28957                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28958                 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));
28959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28960         }
28961         if (flags & NDR_OUT) {
28962                 if (r->out._ndr_size == NULL) {
28963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28964                 }
28965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28966                 if (r->out.key_buffer == NULL) {
28967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28968                 }
28969                 {
28970                         struct ndr_push *_ndr_key_buffer;
28971                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28972                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28973                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28974                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28975                 }
28976                 if (r->out.needed == NULL) {
28977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28978                 }
28979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28981         }
28982         return NDR_ERR_SUCCESS;
28983 }
28984
28985 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28986 {
28987         TALLOC_CTX *_mem_save_handle_0;
28988         TALLOC_CTX *_mem_save__ndr_size_0;
28989         TALLOC_CTX *_mem_save_key_buffer_0;
28990         TALLOC_CTX *_mem_save_needed_0;
28991         if (flags & NDR_IN) {
28992                 ZERO_STRUCT(r->out);
28993
28994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28995                         NDR_PULL_ALLOC(ndr, r->in.handle);
28996                 }
28997                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28998                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28999                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29001                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29002                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29003                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
29004                         return 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));
29005                 }
29006                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
29007                 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));
29008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
29009                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
29010                 ZERO_STRUCTP(r->out._ndr_size);
29011                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
29012                 ZERO_STRUCTP(r->out.key_buffer);
29013                 NDR_PULL_ALLOC(ndr, r->out.needed);
29014                 ZERO_STRUCTP(r->out.needed);
29015         }
29016         if (flags & NDR_OUT) {
29017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29018                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
29019                 }
29020                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
29021                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
29022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
29023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
29024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29025                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
29026                 }
29027                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
29028                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
29029                 {
29030                         struct ndr_pull *_ndr_key_buffer;
29031                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
29032                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
29033                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
29034                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
29035                 }
29036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
29037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29038                         NDR_PULL_ALLOC(ndr, r->out.needed);
29039                 }
29040                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29045         }
29046         return NDR_ERR_SUCCESS;
29047 }
29048
29049 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
29050 {
29051         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
29052         ndr->depth++;
29053         if (flags & NDR_SET_VALUES) {
29054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29055         }
29056         if (flags & NDR_IN) {
29057                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
29058                 ndr->depth++;
29059                 ndr_print_ptr(ndr, "handle", r->in.handle);
29060                 ndr->depth++;
29061                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29062                 ndr->depth--;
29063                 ndr_print_string(ndr, "key_name", r->in.key_name);
29064                 ndr_print_uint32(ndr, "offered", r->in.offered);
29065                 ndr->depth--;
29066         }
29067         if (flags & NDR_OUT) {
29068                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
29069                 ndr->depth++;
29070                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
29071                 ndr->depth++;
29072                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
29073                 ndr->depth--;
29074                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
29075                 ndr->depth++;
29076                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
29077                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
29078                 ndr->depth--;
29079                 ndr_print_ptr(ndr, "needed", r->out.needed);
29080                 ndr->depth++;
29081                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29082                 ndr->depth--;
29083                 ndr_print_WERROR(ndr, "result", r->out.result);
29084                 ndr->depth--;
29085         }
29086         ndr->depth--;
29087 }
29088
29089 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
29090 {
29091         if (flags & NDR_IN) {
29092                 if (r->in.handle == NULL) {
29093                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29094                 }
29095                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29096                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29098                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29099                 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));
29100                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29101                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29102                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
29103                 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));
29104         }
29105         if (flags & NDR_OUT) {
29106                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29107         }
29108         return NDR_ERR_SUCCESS;
29109 }
29110
29111 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
29112 {
29113         TALLOC_CTX *_mem_save_handle_0;
29114         if (flags & NDR_IN) {
29115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29116                         NDR_PULL_ALLOC(ndr, r->in.handle);
29117                 }
29118                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29119                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29120                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29122                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29123                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29124                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
29125                         return 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));
29126                 }
29127                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
29128                 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));
29129                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
29130                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
29131                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
29132                         return 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));
29133                 }
29134                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
29135                 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));
29136         }
29137         if (flags & NDR_OUT) {
29138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29139         }
29140         return NDR_ERR_SUCCESS;
29141 }
29142
29143 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
29144 {
29145         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
29146         ndr->depth++;
29147         if (flags & NDR_SET_VALUES) {
29148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29149         }
29150         if (flags & NDR_IN) {
29151                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
29152                 ndr->depth++;
29153                 ndr_print_ptr(ndr, "handle", r->in.handle);
29154                 ndr->depth++;
29155                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29156                 ndr->depth--;
29157                 ndr_print_string(ndr, "key_name", r->in.key_name);
29158                 ndr_print_string(ndr, "value_name", r->in.value_name);
29159                 ndr->depth--;
29160         }
29161         if (flags & NDR_OUT) {
29162                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
29163                 ndr->depth++;
29164                 ndr_print_WERROR(ndr, "result", r->out.result);
29165                 ndr->depth--;
29166         }
29167         ndr->depth--;
29168 }
29169
29170 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
29171 {
29172         if (flags & NDR_IN) {
29173                 if (r->in.handle == NULL) {
29174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29175                 }
29176                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29177                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29178                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29179                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
29180                 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));
29181         }
29182         if (flags & NDR_OUT) {
29183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29184         }
29185         return NDR_ERR_SUCCESS;
29186 }
29187
29188 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
29189 {
29190         TALLOC_CTX *_mem_save_handle_0;
29191         if (flags & NDR_IN) {
29192                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29193                         NDR_PULL_ALLOC(ndr, r->in.handle);
29194                 }
29195                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29196                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29197                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29198                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29199                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
29200                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
29201                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
29202                         return 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));
29203                 }
29204                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
29205                 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));
29206         }
29207         if (flags & NDR_OUT) {
29208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29209         }
29210         return NDR_ERR_SUCCESS;
29211 }
29212
29213 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
29214 {
29215         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
29216         ndr->depth++;
29217         if (flags & NDR_SET_VALUES) {
29218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29219         }
29220         if (flags & NDR_IN) {
29221                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
29222                 ndr->depth++;
29223                 ndr_print_ptr(ndr, "handle", r->in.handle);
29224                 ndr->depth++;
29225                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29226                 ndr->depth--;
29227                 ndr_print_string(ndr, "key_name", r->in.key_name);
29228                 ndr->depth--;
29229         }
29230         if (flags & NDR_OUT) {
29231                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
29232                 ndr->depth++;
29233                 ndr_print_WERROR(ndr, "result", r->out.result);
29234                 ndr->depth--;
29235         }
29236         ndr->depth--;
29237 }
29238
29239 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
29240 {
29241         if (flags & NDR_IN) {
29242         }
29243         if (flags & NDR_OUT) {
29244                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29245         }
29246         return NDR_ERR_SUCCESS;
29247 }
29248
29249 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
29250 {
29251         if (flags & NDR_IN) {
29252         }
29253         if (flags & NDR_OUT) {
29254                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29255         }
29256         return NDR_ERR_SUCCESS;
29257 }
29258
29259 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
29260 {
29261         ndr_print_struct(ndr, name, "spoolss_53");
29262         ndr->depth++;
29263         if (flags & NDR_SET_VALUES) {
29264                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29265         }
29266         if (flags & NDR_IN) {
29267                 ndr_print_struct(ndr, "in", "spoolss_53");
29268                 ndr->depth++;
29269                 ndr->depth--;
29270         }
29271         if (flags & NDR_OUT) {
29272                 ndr_print_struct(ndr, "out", "spoolss_53");
29273                 ndr->depth++;
29274                 ndr_print_WERROR(ndr, "result", r->out.result);
29275                 ndr->depth--;
29276         }
29277         ndr->depth--;
29278 }
29279
29280 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29281 {
29282         if (flags & NDR_IN) {
29283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
29284                 if (r->in.server) {
29285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
29288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29289                 }
29290                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29291                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29292                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29293                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29294                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29295                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29296                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
29297                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29298                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
29299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
29300         }
29301         if (flags & NDR_OUT) {
29302                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29303         }
29304         return NDR_ERR_SUCCESS;
29305 }
29306
29307 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
29308 {
29309         uint32_t _ptr_server;
29310         TALLOC_CTX *_mem_save_server_0;
29311         if (flags & NDR_IN) {
29312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
29313                 if (_ptr_server) {
29314                         NDR_PULL_ALLOC(ndr, r->in.server);
29315                 } else {
29316                         r->in.server = NULL;
29317                 }
29318                 if (r->in.server) {
29319                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
29320                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
29321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
29322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
29323                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
29324                                 return 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));
29325                         }
29326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
29327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
29328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
29329                 }
29330                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29331                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29332                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29333                         return 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));
29334                 }
29335                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29336                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29337                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
29338                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
29339                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
29340                         return 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));
29341                 }
29342                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
29343                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
29344                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
29345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
29346         }
29347         if (flags & NDR_OUT) {
29348                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29349         }
29350         return NDR_ERR_SUCCESS;
29351 }
29352
29353 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
29354 {
29355         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
29356         ndr->depth++;
29357         if (flags & NDR_SET_VALUES) {
29358                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29359         }
29360         if (flags & NDR_IN) {
29361                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
29362                 ndr->depth++;
29363                 ndr_print_ptr(ndr, "server", r->in.server);
29364                 ndr->depth++;
29365                 if (r->in.server) {
29366                         ndr_print_string(ndr, "server", r->in.server);
29367                 }
29368                 ndr->depth--;
29369                 ndr_print_string(ndr, "architecture", r->in.architecture);
29370                 ndr_print_string(ndr, "driver", r->in.driver);
29371                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
29372                 ndr_print_uint32(ndr, "version", r->in.version);
29373                 ndr->depth--;
29374         }
29375         if (flags & NDR_OUT) {
29376                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
29377                 ndr->depth++;
29378                 ndr_print_WERROR(ndr, "result", r->out.result);
29379                 ndr->depth--;
29380         }
29381         ndr->depth--;
29382 }
29383
29384 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
29385 {
29386         if (flags & NDR_IN) {
29387         }
29388         if (flags & NDR_OUT) {
29389                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29390         }
29391         return NDR_ERR_SUCCESS;
29392 }
29393
29394 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
29395 {
29396         if (flags & NDR_IN) {
29397         }
29398         if (flags & NDR_OUT) {
29399                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29400         }
29401         return NDR_ERR_SUCCESS;
29402 }
29403
29404 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
29405 {
29406         ndr_print_struct(ndr, name, "spoolss_55");
29407         ndr->depth++;
29408         if (flags & NDR_SET_VALUES) {
29409                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29410         }
29411         if (flags & NDR_IN) {
29412                 ndr_print_struct(ndr, "in", "spoolss_55");
29413                 ndr->depth++;
29414                 ndr->depth--;
29415         }
29416         if (flags & NDR_OUT) {
29417                 ndr_print_struct(ndr, "out", "spoolss_55");
29418                 ndr->depth++;
29419                 ndr_print_WERROR(ndr, "result", r->out.result);
29420                 ndr->depth--;
29421         }
29422         ndr->depth--;
29423 }
29424
29425 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
29426 {
29427         if (flags & NDR_IN) {
29428         }
29429         if (flags & NDR_OUT) {
29430                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29431         }
29432         return NDR_ERR_SUCCESS;
29433 }
29434
29435 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
29436 {
29437         if (flags & NDR_IN) {
29438         }
29439         if (flags & NDR_OUT) {
29440                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29441         }
29442         return NDR_ERR_SUCCESS;
29443 }
29444
29445 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
29446 {
29447         ndr_print_struct(ndr, name, "spoolss_56");
29448         ndr->depth++;
29449         if (flags & NDR_SET_VALUES) {
29450                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29451         }
29452         if (flags & NDR_IN) {
29453                 ndr_print_struct(ndr, "in", "spoolss_56");
29454                 ndr->depth++;
29455                 ndr->depth--;
29456         }
29457         if (flags & NDR_OUT) {
29458                 ndr_print_struct(ndr, "out", "spoolss_56");
29459                 ndr->depth++;
29460                 ndr_print_WERROR(ndr, "result", r->out.result);
29461                 ndr->depth--;
29462         }
29463         ndr->depth--;
29464 }
29465
29466 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
29467 {
29468         if (flags & NDR_IN) {
29469         }
29470         if (flags & NDR_OUT) {
29471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29472         }
29473         return NDR_ERR_SUCCESS;
29474 }
29475
29476 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
29477 {
29478         if (flags & NDR_IN) {
29479         }
29480         if (flags & NDR_OUT) {
29481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29482         }
29483         return NDR_ERR_SUCCESS;
29484 }
29485
29486 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
29487 {
29488         ndr_print_struct(ndr, name, "spoolss_57");
29489         ndr->depth++;
29490         if (flags & NDR_SET_VALUES) {
29491                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29492         }
29493         if (flags & NDR_IN) {
29494                 ndr_print_struct(ndr, "in", "spoolss_57");
29495                 ndr->depth++;
29496                 ndr->depth--;
29497         }
29498         if (flags & NDR_OUT) {
29499                 ndr_print_struct(ndr, "out", "spoolss_57");
29500                 ndr->depth++;
29501                 ndr_print_WERROR(ndr, "result", r->out.result);
29502                 ndr->depth--;
29503         }
29504         ndr->depth--;
29505 }
29506
29507 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29508 {
29509         if (flags & NDR_IN) {
29510                 if (r->in.handle == NULL) {
29511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29512                 }
29513                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29514                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29515                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29516                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29517                 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));
29518                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29521                 if (r->in.status_code == NULL) {
29522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29523                 }
29524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29525         }
29526         if (flags & NDR_OUT) {
29527                 if (r->out.out_data == NULL) {
29528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29529                 }
29530                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29531                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29532                 if (r->out.needed == NULL) {
29533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29534                 }
29535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29536                 if (r->out.status_code == NULL) {
29537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29538                 }
29539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29540                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29541         }
29542         return NDR_ERR_SUCCESS;
29543 }
29544
29545 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29546 {
29547         TALLOC_CTX *_mem_save_handle_0;
29548         TALLOC_CTX *_mem_save_needed_0;
29549         TALLOC_CTX *_mem_save_status_code_0;
29550         if (flags & NDR_IN) {
29551                 ZERO_STRUCT(r->out);
29552
29553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29554                         NDR_PULL_ALLOC(ndr, r->in.handle);
29555                 }
29556                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29558                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29560                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29561                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29562                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29563                         return 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));
29564                 }
29565                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29566                 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));
29567                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29571                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29572                 }
29573                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29574                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29577                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29578                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29579                 NDR_PULL_ALLOC(ndr, r->out.needed);
29580                 ZERO_STRUCTP(r->out.needed);
29581                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29582                 *r->out.status_code = *r->in.status_code;
29583         }
29584         if (flags & NDR_OUT) {
29585                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29586                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29587                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29588                 }
29589                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29591                         NDR_PULL_ALLOC(ndr, r->out.needed);
29592                 }
29593                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29594                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29598                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29599                 }
29600                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29601                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29604                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29605                 if (r->out.out_data) {
29606                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29607                 }
29608         }
29609         return NDR_ERR_SUCCESS;
29610 }
29611
29612 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29613 {
29614         ndr_print_struct(ndr, name, "spoolss_XcvData");
29615         ndr->depth++;
29616         if (flags & NDR_SET_VALUES) {
29617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29618         }
29619         if (flags & NDR_IN) {
29620                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29621                 ndr->depth++;
29622                 ndr_print_ptr(ndr, "handle", r->in.handle);
29623                 ndr->depth++;
29624                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29625                 ndr->depth--;
29626                 ndr_print_string(ndr, "function_name", r->in.function_name);
29627                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29628                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29629                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29630                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29631                 ndr->depth++;
29632                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29633                 ndr->depth--;
29634                 ndr->depth--;
29635         }
29636         if (flags & NDR_OUT) {
29637                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29638                 ndr->depth++;
29639                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29640                 ndr->depth++;
29641                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29642                 ndr->depth--;
29643                 ndr_print_ptr(ndr, "needed", r->out.needed);
29644                 ndr->depth++;
29645                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29646                 ndr->depth--;
29647                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29648                 ndr->depth++;
29649                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29650                 ndr->depth--;
29651                 ndr_print_WERROR(ndr, "result", r->out.result);
29652                 ndr->depth--;
29653         }
29654         ndr->depth--;
29655 }
29656
29657 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29658 {
29659         if (flags & NDR_IN) {
29660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29661                 if (r->in.servername) {
29662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29665                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29666                 }
29667                 if (r->in.info_ctr == NULL) {
29668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29669                 }
29670                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29671                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29672         }
29673         if (flags & NDR_OUT) {
29674                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29675         }
29676         return NDR_ERR_SUCCESS;
29677 }
29678
29679 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29680 {
29681         uint32_t _ptr_servername;
29682         TALLOC_CTX *_mem_save_servername_0;
29683         TALLOC_CTX *_mem_save_info_ctr_0;
29684         if (flags & NDR_IN) {
29685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29686                 if (_ptr_servername) {
29687                         NDR_PULL_ALLOC(ndr, r->in.servername);
29688                 } else {
29689                         r->in.servername = NULL;
29690                 }
29691                 if (r->in.servername) {
29692                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29693                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29694                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29695                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29696                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29697                                 return 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));
29698                         }
29699                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29700                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29701                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29702                 }
29703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29704                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29705                 }
29706                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29708                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29710                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29711         }
29712         if (flags & NDR_OUT) {
29713                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29714         }
29715         return NDR_ERR_SUCCESS;
29716 }
29717
29718 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29719 {
29720         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29721         ndr->depth++;
29722         if (flags & NDR_SET_VALUES) {
29723                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29724         }
29725         if (flags & NDR_IN) {
29726                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29727                 ndr->depth++;
29728                 ndr_print_ptr(ndr, "servername", r->in.servername);
29729                 ndr->depth++;
29730                 if (r->in.servername) {
29731                         ndr_print_string(ndr, "servername", r->in.servername);
29732                 }
29733                 ndr->depth--;
29734                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29735                 ndr->depth++;
29736                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29737                 ndr->depth--;
29738                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29739                 ndr->depth--;
29740         }
29741         if (flags & NDR_OUT) {
29742                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29743                 ndr->depth++;
29744                 ndr_print_WERROR(ndr, "result", r->out.result);
29745                 ndr->depth--;
29746         }
29747         ndr->depth--;
29748 }
29749
29750 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29751 {
29752         if (flags & NDR_IN) {
29753         }
29754         if (flags & NDR_OUT) {
29755                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29756         }
29757         return NDR_ERR_SUCCESS;
29758 }
29759
29760 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29761 {
29762         if (flags & NDR_IN) {
29763         }
29764         if (flags & NDR_OUT) {
29765                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29766         }
29767         return NDR_ERR_SUCCESS;
29768 }
29769
29770 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29771 {
29772         ndr_print_struct(ndr, name, "spoolss_5a");
29773         ndr->depth++;
29774         if (flags & NDR_SET_VALUES) {
29775                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29776         }
29777         if (flags & NDR_IN) {
29778                 ndr_print_struct(ndr, "in", "spoolss_5a");
29779                 ndr->depth++;
29780                 ndr->depth--;
29781         }
29782         if (flags & NDR_OUT) {
29783                 ndr_print_struct(ndr, "out", "spoolss_5a");
29784                 ndr->depth++;
29785                 ndr_print_WERROR(ndr, "result", r->out.result);
29786                 ndr->depth--;
29787         }
29788         ndr->depth--;
29789 }
29790
29791 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29792 {
29793         if (flags & NDR_IN) {
29794         }
29795         if (flags & NDR_OUT) {
29796                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29797         }
29798         return NDR_ERR_SUCCESS;
29799 }
29800
29801 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29802 {
29803         if (flags & NDR_IN) {
29804         }
29805         if (flags & NDR_OUT) {
29806                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29807         }
29808         return NDR_ERR_SUCCESS;
29809 }
29810
29811 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29812 {
29813         ndr_print_struct(ndr, name, "spoolss_5b");
29814         ndr->depth++;
29815         if (flags & NDR_SET_VALUES) {
29816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29817         }
29818         if (flags & NDR_IN) {
29819                 ndr_print_struct(ndr, "in", "spoolss_5b");
29820                 ndr->depth++;
29821                 ndr->depth--;
29822         }
29823         if (flags & NDR_OUT) {
29824                 ndr_print_struct(ndr, "out", "spoolss_5b");
29825                 ndr->depth++;
29826                 ndr_print_WERROR(ndr, "result", r->out.result);
29827                 ndr->depth--;
29828         }
29829         ndr->depth--;
29830 }
29831
29832 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29833 {
29834         if (flags & NDR_IN) {
29835         }
29836         if (flags & NDR_OUT) {
29837                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29838         }
29839         return NDR_ERR_SUCCESS;
29840 }
29841
29842 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29843 {
29844         if (flags & NDR_IN) {
29845         }
29846         if (flags & NDR_OUT) {
29847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29848         }
29849         return NDR_ERR_SUCCESS;
29850 }
29851
29852 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29853 {
29854         ndr_print_struct(ndr, name, "spoolss_5c");
29855         ndr->depth++;
29856         if (flags & NDR_SET_VALUES) {
29857                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29858         }
29859         if (flags & NDR_IN) {
29860                 ndr_print_struct(ndr, "in", "spoolss_5c");
29861                 ndr->depth++;
29862                 ndr->depth--;
29863         }
29864         if (flags & NDR_OUT) {
29865                 ndr_print_struct(ndr, "out", "spoolss_5c");
29866                 ndr->depth++;
29867                 ndr_print_WERROR(ndr, "result", r->out.result);
29868                 ndr->depth--;
29869         }
29870         ndr->depth--;
29871 }
29872
29873 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29874 {
29875         if (flags & NDR_IN) {
29876         }
29877         if (flags & NDR_OUT) {
29878                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29879         }
29880         return NDR_ERR_SUCCESS;
29881 }
29882
29883 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29884 {
29885         if (flags & NDR_IN) {
29886         }
29887         if (flags & NDR_OUT) {
29888                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29889         }
29890         return NDR_ERR_SUCCESS;
29891 }
29892
29893 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29894 {
29895         ndr_print_struct(ndr, name, "spoolss_5d");
29896         ndr->depth++;
29897         if (flags & NDR_SET_VALUES) {
29898                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29899         }
29900         if (flags & NDR_IN) {
29901                 ndr_print_struct(ndr, "in", "spoolss_5d");
29902                 ndr->depth++;
29903                 ndr->depth--;
29904         }
29905         if (flags & NDR_OUT) {
29906                 ndr_print_struct(ndr, "out", "spoolss_5d");
29907                 ndr->depth++;
29908                 ndr_print_WERROR(ndr, "result", r->out.result);
29909                 ndr->depth--;
29910         }
29911         ndr->depth--;
29912 }
29913
29914 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29915 {
29916         if (flags & NDR_IN) {
29917         }
29918         if (flags & NDR_OUT) {
29919                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29920         }
29921         return NDR_ERR_SUCCESS;
29922 }
29923
29924 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29925 {
29926         if (flags & NDR_IN) {
29927         }
29928         if (flags & NDR_OUT) {
29929                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29930         }
29931         return NDR_ERR_SUCCESS;
29932 }
29933
29934 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29935 {
29936         ndr_print_struct(ndr, name, "spoolss_5e");
29937         ndr->depth++;
29938         if (flags & NDR_SET_VALUES) {
29939                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29940         }
29941         if (flags & NDR_IN) {
29942                 ndr_print_struct(ndr, "in", "spoolss_5e");
29943                 ndr->depth++;
29944                 ndr->depth--;
29945         }
29946         if (flags & NDR_OUT) {
29947                 ndr_print_struct(ndr, "out", "spoolss_5e");
29948                 ndr->depth++;
29949                 ndr_print_WERROR(ndr, "result", r->out.result);
29950                 ndr->depth--;
29951         }
29952         ndr->depth--;
29953 }
29954
29955 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29956 {
29957         if (flags & NDR_IN) {
29958         }
29959         if (flags & NDR_OUT) {
29960                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29961         }
29962         return NDR_ERR_SUCCESS;
29963 }
29964
29965 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29966 {
29967         if (flags & NDR_IN) {
29968         }
29969         if (flags & NDR_OUT) {
29970                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29971         }
29972         return NDR_ERR_SUCCESS;
29973 }
29974
29975 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29976 {
29977         ndr_print_struct(ndr, name, "spoolss_5f");
29978         ndr->depth++;
29979         if (flags & NDR_SET_VALUES) {
29980                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29981         }
29982         if (flags & NDR_IN) {
29983                 ndr_print_struct(ndr, "in", "spoolss_5f");
29984                 ndr->depth++;
29985                 ndr->depth--;
29986         }
29987         if (flags & NDR_OUT) {
29988                 ndr_print_struct(ndr, "out", "spoolss_5f");
29989                 ndr->depth++;
29990                 ndr_print_WERROR(ndr, "result", r->out.result);
29991                 ndr->depth--;
29992         }
29993         ndr->depth--;
29994 }
29995
29996 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29997 {
29998         if (flags & NDR_IN) {
29999         }
30000         if (flags & NDR_OUT) {
30001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30002         }
30003         return NDR_ERR_SUCCESS;
30004 }
30005
30006 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
30007 {
30008         if (flags & NDR_IN) {
30009         }
30010         if (flags & NDR_OUT) {
30011                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30012         }
30013         return NDR_ERR_SUCCESS;
30014 }
30015
30016 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
30017 {
30018         ndr_print_struct(ndr, name, "spoolss_60");
30019         ndr->depth++;
30020         if (flags & NDR_SET_VALUES) {
30021                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30022         }
30023         if (flags & NDR_IN) {
30024                 ndr_print_struct(ndr, "in", "spoolss_60");
30025                 ndr->depth++;
30026                 ndr->depth--;
30027         }
30028         if (flags & NDR_OUT) {
30029                 ndr_print_struct(ndr, "out", "spoolss_60");
30030                 ndr->depth++;
30031                 ndr_print_WERROR(ndr, "result", r->out.result);
30032                 ndr->depth--;
30033         }
30034         ndr->depth--;
30035 }
30036
30037 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
30038 {
30039         if (flags & NDR_IN) {
30040         }
30041         if (flags & NDR_OUT) {
30042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30043         }
30044         return NDR_ERR_SUCCESS;
30045 }
30046
30047 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
30048 {
30049         if (flags & NDR_IN) {
30050         }
30051         if (flags & NDR_OUT) {
30052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30053         }
30054         return NDR_ERR_SUCCESS;
30055 }
30056
30057 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
30058 {
30059         ndr_print_struct(ndr, name, "spoolss_61");
30060         ndr->depth++;
30061         if (flags & NDR_SET_VALUES) {
30062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30063         }
30064         if (flags & NDR_IN) {
30065                 ndr_print_struct(ndr, "in", "spoolss_61");
30066                 ndr->depth++;
30067                 ndr->depth--;
30068         }
30069         if (flags & NDR_OUT) {
30070                 ndr_print_struct(ndr, "out", "spoolss_61");
30071                 ndr->depth++;
30072                 ndr_print_WERROR(ndr, "result", r->out.result);
30073                 ndr->depth--;
30074         }
30075         ndr->depth--;
30076 }
30077
30078 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
30079 {
30080         if (flags & NDR_IN) {
30081         }
30082         if (flags & NDR_OUT) {
30083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30084         }
30085         return NDR_ERR_SUCCESS;
30086 }
30087
30088 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
30089 {
30090         if (flags & NDR_IN) {
30091         }
30092         if (flags & NDR_OUT) {
30093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30094         }
30095         return NDR_ERR_SUCCESS;
30096 }
30097
30098 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
30099 {
30100         ndr_print_struct(ndr, name, "spoolss_62");
30101         ndr->depth++;
30102         if (flags & NDR_SET_VALUES) {
30103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30104         }
30105         if (flags & NDR_IN) {
30106                 ndr_print_struct(ndr, "in", "spoolss_62");
30107                 ndr->depth++;
30108                 ndr->depth--;
30109         }
30110         if (flags & NDR_OUT) {
30111                 ndr_print_struct(ndr, "out", "spoolss_62");
30112                 ndr->depth++;
30113                 ndr_print_WERROR(ndr, "result", r->out.result);
30114                 ndr->depth--;
30115         }
30116         ndr->depth--;
30117 }
30118
30119 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
30120 {
30121         if (flags & NDR_IN) {
30122         }
30123         if (flags & NDR_OUT) {
30124                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30125         }
30126         return NDR_ERR_SUCCESS;
30127 }
30128
30129 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
30130 {
30131         if (flags & NDR_IN) {
30132         }
30133         if (flags & NDR_OUT) {
30134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30135         }
30136         return NDR_ERR_SUCCESS;
30137 }
30138
30139 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
30140 {
30141         ndr_print_struct(ndr, name, "spoolss_63");
30142         ndr->depth++;
30143         if (flags & NDR_SET_VALUES) {
30144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30145         }
30146         if (flags & NDR_IN) {
30147                 ndr_print_struct(ndr, "in", "spoolss_63");
30148                 ndr->depth++;
30149                 ndr->depth--;
30150         }
30151         if (flags & NDR_OUT) {
30152                 ndr_print_struct(ndr, "out", "spoolss_63");
30153                 ndr->depth++;
30154                 ndr_print_WERROR(ndr, "result", r->out.result);
30155                 ndr->depth--;
30156         }
30157         ndr->depth--;
30158 }
30159
30160 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
30161 {
30162         if (flags & NDR_IN) {
30163         }
30164         if (flags & NDR_OUT) {
30165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30166         }
30167         return NDR_ERR_SUCCESS;
30168 }
30169
30170 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
30171 {
30172         if (flags & NDR_IN) {
30173         }
30174         if (flags & NDR_OUT) {
30175                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30176         }
30177         return NDR_ERR_SUCCESS;
30178 }
30179
30180 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
30181 {
30182         ndr_print_struct(ndr, name, "spoolss_64");
30183         ndr->depth++;
30184         if (flags & NDR_SET_VALUES) {
30185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30186         }
30187         if (flags & NDR_IN) {
30188                 ndr_print_struct(ndr, "in", "spoolss_64");
30189                 ndr->depth++;
30190                 ndr->depth--;
30191         }
30192         if (flags & NDR_OUT) {
30193                 ndr_print_struct(ndr, "out", "spoolss_64");
30194                 ndr->depth++;
30195                 ndr_print_WERROR(ndr, "result", r->out.result);
30196                 ndr->depth--;
30197         }
30198         ndr->depth--;
30199 }
30200
30201 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
30202 {
30203         if (flags & NDR_IN) {
30204         }
30205         if (flags & NDR_OUT) {
30206                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30207         }
30208         return NDR_ERR_SUCCESS;
30209 }
30210
30211 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
30212 {
30213         if (flags & NDR_IN) {
30214         }
30215         if (flags & NDR_OUT) {
30216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30217         }
30218         return NDR_ERR_SUCCESS;
30219 }
30220
30221 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
30222 {
30223         ndr_print_struct(ndr, name, "spoolss_65");
30224         ndr->depth++;
30225         if (flags & NDR_SET_VALUES) {
30226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30227         }
30228         if (flags & NDR_IN) {
30229                 ndr_print_struct(ndr, "in", "spoolss_65");
30230                 ndr->depth++;
30231                 ndr->depth--;
30232         }
30233         if (flags & NDR_OUT) {
30234                 ndr_print_struct(ndr, "out", "spoolss_65");
30235                 ndr->depth++;
30236                 ndr_print_WERROR(ndr, "result", r->out.result);
30237                 ndr->depth--;
30238         }
30239         ndr->depth--;
30240 }
30241
30242 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30243 {
30244         uint32_t cntr_core_printer_drivers_1;
30245         if (flags & NDR_IN) {
30246                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30247                 if (r->in.servername) {
30248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30251                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30252                 }
30253                 if (r->in.architecture == NULL) {
30254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30255                 }
30256                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30257                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30258                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30259                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
30261                 if (r->in.core_driver_dependencies == NULL) {
30262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30263                 }
30264                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
30265                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
30266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30267         }
30268         if (flags & NDR_OUT) {
30269                 if (r->out.core_printer_drivers == NULL) {
30270                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30271                 }
30272                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
30273                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30274                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30275                 }
30276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30277         }
30278         return NDR_ERR_SUCCESS;
30279 }
30280
30281 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
30282 {
30283         uint32_t _ptr_servername;
30284         uint32_t cntr_core_printer_drivers_1;
30285         TALLOC_CTX *_mem_save_servername_0;
30286         TALLOC_CTX *_mem_save_core_printer_drivers_1;
30287         if (flags & NDR_IN) {
30288                 ZERO_STRUCT(r->out);
30289
30290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30291                 if (_ptr_servername) {
30292                         NDR_PULL_ALLOC(ndr, r->in.servername);
30293                 } else {
30294                         r->in.servername = NULL;
30295                 }
30296                 if (r->in.servername) {
30297                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30298                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30299                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30300                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30301                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30302                                 return 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));
30303                         }
30304                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30305                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30307                 }
30308                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30309                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30310                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30311                         return 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));
30312                 }
30313                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30314                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
30316                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
30317                 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));
30318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
30319                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
30320                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
30321                 if (r->in.core_driver_dependencies) {
30322                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
30323                 }
30324         }
30325         if (flags & NDR_OUT) {
30326                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
30327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30328                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
30329                 }
30330                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
30331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
30332                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
30333                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
30334                 }
30335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
30336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30337                 if (r->out.core_printer_drivers) {
30338                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
30339                 }
30340         }
30341         return NDR_ERR_SUCCESS;
30342 }
30343
30344 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
30345 {
30346         uint32_t cntr_core_printer_drivers_1;
30347         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
30348         ndr->depth++;
30349         if (flags & NDR_SET_VALUES) {
30350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30351         }
30352         if (flags & NDR_IN) {
30353                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
30354                 ndr->depth++;
30355                 ndr_print_ptr(ndr, "servername", r->in.servername);
30356                 ndr->depth++;
30357                 if (r->in.servername) {
30358                         ndr_print_string(ndr, "servername", r->in.servername);
30359                 }
30360                 ndr->depth--;
30361                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30362                 ndr->depth++;
30363                 ndr_print_string(ndr, "architecture", r->in.architecture);
30364                 ndr->depth--;
30365                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
30366                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30367                 ndr->depth++;
30368                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
30369                 ndr->depth--;
30370                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
30371                 ndr->depth--;
30372         }
30373         if (flags & NDR_OUT) {
30374                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
30375                 ndr->depth++;
30376                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
30377                 ndr->depth++;
30378                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
30379                 ndr->depth++;
30380                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
30381                         char *idx_1=NULL;
30382                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
30383                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
30384                                 free(idx_1);
30385                         }
30386                 }
30387                 ndr->depth--;
30388                 ndr->depth--;
30389                 ndr_print_WERROR(ndr, "result", r->out.result);
30390                 ndr->depth--;
30391         }
30392         ndr->depth--;
30393 }
30394
30395 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
30396 {
30397         if (flags & NDR_IN) {
30398         }
30399         if (flags & NDR_OUT) {
30400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30401         }
30402         return NDR_ERR_SUCCESS;
30403 }
30404
30405 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
30406 {
30407         if (flags & NDR_IN) {
30408         }
30409         if (flags & NDR_OUT) {
30410                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30411         }
30412         return NDR_ERR_SUCCESS;
30413 }
30414
30415 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
30416 {
30417         ndr_print_struct(ndr, name, "spoolss_67");
30418         ndr->depth++;
30419         if (flags & NDR_SET_VALUES) {
30420                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30421         }
30422         if (flags & NDR_IN) {
30423                 ndr_print_struct(ndr, "in", "spoolss_67");
30424                 ndr->depth++;
30425                 ndr->depth--;
30426         }
30427         if (flags & NDR_OUT) {
30428                 ndr_print_struct(ndr, "out", "spoolss_67");
30429                 ndr->depth++;
30430                 ndr_print_WERROR(ndr, "result", r->out.result);
30431                 ndr->depth--;
30432         }
30433         ndr->depth--;
30434 }
30435
30436 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30437 {
30438         if (flags & NDR_IN) {
30439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
30440                 if (r->in.servername) {
30441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
30444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30445                 }
30446                 if (r->in.architecture == NULL) {
30447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30448                 }
30449                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30450                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30451                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
30452                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
30454                 if (r->in.language) {
30455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30456                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
30458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
30459                 }
30460                 if (r->in.package_id == NULL) {
30461                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30462                 }
30463                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30464                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
30465                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
30466                 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));
30467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
30468                 if (r->in.driver_package_cab) {
30469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30471                 }
30472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30473         }
30474         if (flags & NDR_OUT) {
30475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
30476                 if (r->out.driver_package_cab) {
30477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
30478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
30479                 }
30480                 if (r->out.required == NULL) {
30481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
30482                 }
30483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
30484                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30485         }
30486         return NDR_ERR_SUCCESS;
30487 }
30488
30489 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
30490 {
30491         uint32_t _ptr_servername;
30492         uint32_t _ptr_language;
30493         uint32_t _ptr_driver_package_cab;
30494         TALLOC_CTX *_mem_save_servername_0;
30495         TALLOC_CTX *_mem_save_language_0;
30496         TALLOC_CTX *_mem_save_driver_package_cab_0;
30497         TALLOC_CTX *_mem_save_required_0;
30498         if (flags & NDR_IN) {
30499                 ZERO_STRUCT(r->out);
30500
30501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
30502                 if (_ptr_servername) {
30503                         NDR_PULL_ALLOC(ndr, r->in.servername);
30504                 } else {
30505                         r->in.servername = NULL;
30506                 }
30507                 if (r->in.servername) {
30508                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30509                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30512                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30513                                 return 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));
30514                         }
30515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30518                 }
30519                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30520                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30521                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30522                         return 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));
30523                 }
30524                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30525                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30527                 if (_ptr_language) {
30528                         NDR_PULL_ALLOC(ndr, r->in.language);
30529                 } else {
30530                         r->in.language = NULL;
30531                 }
30532                 if (r->in.language) {
30533                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30534                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30535                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30536                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30537                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30538                                 return 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));
30539                         }
30540                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30541                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30543                 }
30544                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30545                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30546                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30547                         return 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));
30548                 }
30549                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30550                 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));
30551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30552                 if (_ptr_driver_package_cab) {
30553                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30554                 } else {
30555                         r->in.driver_package_cab = NULL;
30556                 }
30557                 if (r->in.driver_package_cab) {
30558                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30559                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30560                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30561                         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));
30562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30563                 }
30564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30565                 NDR_PULL_ALLOC(ndr, r->out.required);
30566                 ZERO_STRUCTP(r->out.required);
30567                 if (r->in.driver_package_cab) {
30568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30569                 }
30570         }
30571         if (flags & NDR_OUT) {
30572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30573                 if (_ptr_driver_package_cab) {
30574                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30575                 } else {
30576                         r->out.driver_package_cab = NULL;
30577                 }
30578                 if (r->out.driver_package_cab) {
30579                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30580                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30581                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30582                         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));
30583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30584                 }
30585                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30586                         NDR_PULL_ALLOC(ndr, r->out.required);
30587                 }
30588                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30589                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30592                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30593                 if (r->out.driver_package_cab) {
30594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30595                 }
30596         }
30597         return NDR_ERR_SUCCESS;
30598 }
30599
30600 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30601 {
30602         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30603         ndr->depth++;
30604         if (flags & NDR_SET_VALUES) {
30605                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30606         }
30607         if (flags & NDR_IN) {
30608                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30609                 ndr->depth++;
30610                 ndr_print_ptr(ndr, "servername", r->in.servername);
30611                 ndr->depth++;
30612                 if (r->in.servername) {
30613                         ndr_print_string(ndr, "servername", r->in.servername);
30614                 }
30615                 ndr->depth--;
30616                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30617                 ndr->depth++;
30618                 ndr_print_string(ndr, "architecture", r->in.architecture);
30619                 ndr->depth--;
30620                 ndr_print_ptr(ndr, "language", r->in.language);
30621                 ndr->depth++;
30622                 if (r->in.language) {
30623                         ndr_print_string(ndr, "language", r->in.language);
30624                 }
30625                 ndr->depth--;
30626                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30627                 ndr->depth++;
30628                 ndr_print_string(ndr, "package_id", r->in.package_id);
30629                 ndr->depth--;
30630                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30631                 ndr->depth++;
30632                 if (r->in.driver_package_cab) {
30633                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30634                 }
30635                 ndr->depth--;
30636                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30637                 ndr->depth--;
30638         }
30639         if (flags & NDR_OUT) {
30640                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30641                 ndr->depth++;
30642                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30643                 ndr->depth++;
30644                 if (r->out.driver_package_cab) {
30645                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30646                 }
30647                 ndr->depth--;
30648                 ndr_print_ptr(ndr, "required", r->out.required);
30649                 ndr->depth++;
30650                 ndr_print_uint32(ndr, "required", *r->out.required);
30651                 ndr->depth--;
30652                 ndr_print_WERROR(ndr, "result", r->out.result);
30653                 ndr->depth--;
30654         }
30655         ndr->depth--;
30656 }
30657
30658 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30659 {
30660         if (flags & NDR_IN) {
30661         }
30662         if (flags & NDR_OUT) {
30663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30664         }
30665         return NDR_ERR_SUCCESS;
30666 }
30667
30668 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30669 {
30670         if (flags & NDR_IN) {
30671         }
30672         if (flags & NDR_OUT) {
30673                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30674         }
30675         return NDR_ERR_SUCCESS;
30676 }
30677
30678 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30679 {
30680         ndr_print_struct(ndr, name, "spoolss_69");
30681         ndr->depth++;
30682         if (flags & NDR_SET_VALUES) {
30683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30684         }
30685         if (flags & NDR_IN) {
30686                 ndr_print_struct(ndr, "in", "spoolss_69");
30687                 ndr->depth++;
30688                 ndr->depth--;
30689         }
30690         if (flags & NDR_OUT) {
30691                 ndr_print_struct(ndr, "out", "spoolss_69");
30692                 ndr->depth++;
30693                 ndr_print_WERROR(ndr, "result", r->out.result);
30694                 ndr->depth--;
30695         }
30696         ndr->depth--;
30697 }
30698
30699 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30700 {
30701         if (flags & NDR_IN) {
30702         }
30703         if (flags & NDR_OUT) {
30704                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30705         }
30706         return NDR_ERR_SUCCESS;
30707 }
30708
30709 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30710 {
30711         if (flags & NDR_IN) {
30712         }
30713         if (flags & NDR_OUT) {
30714                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30715         }
30716         return NDR_ERR_SUCCESS;
30717 }
30718
30719 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30720 {
30721         ndr_print_struct(ndr, name, "spoolss_6a");
30722         ndr->depth++;
30723         if (flags & NDR_SET_VALUES) {
30724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30725         }
30726         if (flags & NDR_IN) {
30727                 ndr_print_struct(ndr, "in", "spoolss_6a");
30728                 ndr->depth++;
30729                 ndr->depth--;
30730         }
30731         if (flags & NDR_OUT) {
30732                 ndr_print_struct(ndr, "out", "spoolss_6a");
30733                 ndr->depth++;
30734                 ndr_print_WERROR(ndr, "result", r->out.result);
30735                 ndr->depth--;
30736         }
30737         ndr->depth--;
30738 }
30739
30740 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30741 {
30742         if (flags & NDR_IN) {
30743         }
30744         if (flags & NDR_OUT) {
30745                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30746         }
30747         return NDR_ERR_SUCCESS;
30748 }
30749
30750 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30751 {
30752         if (flags & NDR_IN) {
30753         }
30754         if (flags & NDR_OUT) {
30755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30756         }
30757         return NDR_ERR_SUCCESS;
30758 }
30759
30760 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30761 {
30762         ndr_print_struct(ndr, name, "spoolss_6b");
30763         ndr->depth++;
30764         if (flags & NDR_SET_VALUES) {
30765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30766         }
30767         if (flags & NDR_IN) {
30768                 ndr_print_struct(ndr, "in", "spoolss_6b");
30769                 ndr->depth++;
30770                 ndr->depth--;
30771         }
30772         if (flags & NDR_OUT) {
30773                 ndr_print_struct(ndr, "out", "spoolss_6b");
30774                 ndr->depth++;
30775                 ndr_print_WERROR(ndr, "result", r->out.result);
30776                 ndr->depth--;
30777         }
30778         ndr->depth--;
30779 }
30780
30781 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30782 {
30783         if (flags & NDR_IN) {
30784         }
30785         if (flags & NDR_OUT) {
30786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30787         }
30788         return NDR_ERR_SUCCESS;
30789 }
30790
30791 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30792 {
30793         if (flags & NDR_IN) {
30794         }
30795         if (flags & NDR_OUT) {
30796                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30797         }
30798         return NDR_ERR_SUCCESS;
30799 }
30800
30801 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30802 {
30803         ndr_print_struct(ndr, name, "spoolss_6c");
30804         ndr->depth++;
30805         if (flags & NDR_SET_VALUES) {
30806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30807         }
30808         if (flags & NDR_IN) {
30809                 ndr_print_struct(ndr, "in", "spoolss_6c");
30810                 ndr->depth++;
30811                 ndr->depth--;
30812         }
30813         if (flags & NDR_OUT) {
30814                 ndr_print_struct(ndr, "out", "spoolss_6c");
30815                 ndr->depth++;
30816                 ndr_print_WERROR(ndr, "result", r->out.result);
30817                 ndr->depth--;
30818         }
30819         ndr->depth--;
30820 }
30821
30822 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30823 {
30824         if (flags & NDR_IN) {
30825         }
30826         if (flags & NDR_OUT) {
30827                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30828         }
30829         return NDR_ERR_SUCCESS;
30830 }
30831
30832 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30833 {
30834         if (flags & NDR_IN) {
30835         }
30836         if (flags & NDR_OUT) {
30837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30838         }
30839         return NDR_ERR_SUCCESS;
30840 }
30841
30842 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30843 {
30844         ndr_print_struct(ndr, name, "spoolss_6d");
30845         ndr->depth++;
30846         if (flags & NDR_SET_VALUES) {
30847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30848         }
30849         if (flags & NDR_IN) {
30850                 ndr_print_struct(ndr, "in", "spoolss_6d");
30851                 ndr->depth++;
30852                 ndr->depth--;
30853         }
30854         if (flags & NDR_OUT) {
30855                 ndr_print_struct(ndr, "out", "spoolss_6d");
30856                 ndr->depth++;
30857                 ndr_print_WERROR(ndr, "result", r->out.result);
30858                 ndr->depth--;
30859         }
30860         ndr->depth--;
30861 }
30862
30863 static const struct ndr_interface_call spoolss_calls[] = {
30864         {
30865                 "spoolss_EnumPrinters",
30866                 sizeof(struct spoolss_EnumPrinters),
30867                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30868                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30869                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30870                 false,
30871         },
30872         {
30873                 "spoolss_OpenPrinter",
30874                 sizeof(struct spoolss_OpenPrinter),
30875                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30876                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30877                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30878                 false,
30879         },
30880         {
30881                 "spoolss_SetJob",
30882                 sizeof(struct spoolss_SetJob),
30883                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30884                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30885                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30886                 false,
30887         },
30888         {
30889                 "spoolss_GetJob",
30890                 sizeof(struct spoolss_GetJob),
30891                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30892                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30893                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30894                 false,
30895         },
30896         {
30897                 "spoolss_EnumJobs",
30898                 sizeof(struct spoolss_EnumJobs),
30899                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30900                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30901                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30902                 false,
30903         },
30904         {
30905                 "spoolss_AddPrinter",
30906                 sizeof(struct spoolss_AddPrinter),
30907                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30908                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30909                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30910                 false,
30911         },
30912         {
30913                 "spoolss_DeletePrinter",
30914                 sizeof(struct spoolss_DeletePrinter),
30915                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30916                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30917                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30918                 false,
30919         },
30920         {
30921                 "spoolss_SetPrinter",
30922                 sizeof(struct spoolss_SetPrinter),
30923                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30924                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30925                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30926                 false,
30927         },
30928         {
30929                 "spoolss_GetPrinter",
30930                 sizeof(struct spoolss_GetPrinter),
30931                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30932                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30933                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30934                 false,
30935         },
30936         {
30937                 "spoolss_AddPrinterDriver",
30938                 sizeof(struct spoolss_AddPrinterDriver),
30939                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30940                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30941                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30942                 false,
30943         },
30944         {
30945                 "spoolss_EnumPrinterDrivers",
30946                 sizeof(struct spoolss_EnumPrinterDrivers),
30947                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30948                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30949                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30950                 false,
30951         },
30952         {
30953                 "spoolss_GetPrinterDriver",
30954                 sizeof(struct spoolss_GetPrinterDriver),
30955                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30956                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30957                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30958                 false,
30959         },
30960         {
30961                 "spoolss_GetPrinterDriverDirectory",
30962                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30963                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30964                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30965                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30966                 false,
30967         },
30968         {
30969                 "spoolss_DeletePrinterDriver",
30970                 sizeof(struct spoolss_DeletePrinterDriver),
30971                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30972                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30973                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30974                 false,
30975         },
30976         {
30977                 "spoolss_AddPrintProcessor",
30978                 sizeof(struct spoolss_AddPrintProcessor),
30979                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30980                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30981                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30982                 false,
30983         },
30984         {
30985                 "spoolss_EnumPrintProcessors",
30986                 sizeof(struct spoolss_EnumPrintProcessors),
30987                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30988                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30989                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30990                 false,
30991         },
30992         {
30993                 "spoolss_GetPrintProcessorDirectory",
30994                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30995                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30996                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30997                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30998                 false,
30999         },
31000         {
31001                 "spoolss_StartDocPrinter",
31002                 sizeof(struct spoolss_StartDocPrinter),
31003                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
31004                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
31005                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
31006                 false,
31007         },
31008         {
31009                 "spoolss_StartPagePrinter",
31010                 sizeof(struct spoolss_StartPagePrinter),
31011                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
31012                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
31013                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
31014                 false,
31015         },
31016         {
31017                 "spoolss_WritePrinter",
31018                 sizeof(struct spoolss_WritePrinter),
31019                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
31020                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
31021                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
31022                 false,
31023         },
31024         {
31025                 "spoolss_EndPagePrinter",
31026                 sizeof(struct spoolss_EndPagePrinter),
31027                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
31028                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
31029                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
31030                 false,
31031         },
31032         {
31033                 "spoolss_AbortPrinter",
31034                 sizeof(struct spoolss_AbortPrinter),
31035                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
31036                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
31037                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
31038                 false,
31039         },
31040         {
31041                 "spoolss_ReadPrinter",
31042                 sizeof(struct spoolss_ReadPrinter),
31043                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
31044                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
31045                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
31046                 false,
31047         },
31048         {
31049                 "spoolss_EndDocPrinter",
31050                 sizeof(struct spoolss_EndDocPrinter),
31051                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
31052                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
31053                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
31054                 false,
31055         },
31056         {
31057                 "spoolss_AddJob",
31058                 sizeof(struct spoolss_AddJob),
31059                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
31060                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
31061                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
31062                 false,
31063         },
31064         {
31065                 "spoolss_ScheduleJob",
31066                 sizeof(struct spoolss_ScheduleJob),
31067                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
31068                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
31069                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
31070                 false,
31071         },
31072         {
31073                 "spoolss_GetPrinterData",
31074                 sizeof(struct spoolss_GetPrinterData),
31075                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
31076                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
31077                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
31078                 false,
31079         },
31080         {
31081                 "spoolss_SetPrinterData",
31082                 sizeof(struct spoolss_SetPrinterData),
31083                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
31084                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
31085                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
31086                 false,
31087         },
31088         {
31089                 "spoolss_WaitForPrinterChange",
31090                 sizeof(struct spoolss_WaitForPrinterChange),
31091                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
31092                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
31093                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
31094                 false,
31095         },
31096         {
31097                 "spoolss_ClosePrinter",
31098                 sizeof(struct spoolss_ClosePrinter),
31099                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
31100                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
31101                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
31102                 false,
31103         },
31104         {
31105                 "spoolss_AddForm",
31106                 sizeof(struct spoolss_AddForm),
31107                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
31108                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
31109                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
31110                 false,
31111         },
31112         {
31113                 "spoolss_DeleteForm",
31114                 sizeof(struct spoolss_DeleteForm),
31115                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
31116                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
31117                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
31118                 false,
31119         },
31120         {
31121                 "spoolss_GetForm",
31122                 sizeof(struct spoolss_GetForm),
31123                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
31124                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
31125                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
31126                 false,
31127         },
31128         {
31129                 "spoolss_SetForm",
31130                 sizeof(struct spoolss_SetForm),
31131                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
31132                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
31133                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
31134                 false,
31135         },
31136         {
31137                 "spoolss_EnumForms",
31138                 sizeof(struct spoolss_EnumForms),
31139                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
31140                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
31141                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
31142                 false,
31143         },
31144         {
31145                 "spoolss_EnumPorts",
31146                 sizeof(struct spoolss_EnumPorts),
31147                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
31148                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
31149                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
31150                 false,
31151         },
31152         {
31153                 "spoolss_EnumMonitors",
31154                 sizeof(struct spoolss_EnumMonitors),
31155                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
31156                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
31157                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
31158                 false,
31159         },
31160         {
31161                 "spoolss_AddPort",
31162                 sizeof(struct spoolss_AddPort),
31163                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
31164                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
31165                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
31166                 false,
31167         },
31168         {
31169                 "spoolss_ConfigurePort",
31170                 sizeof(struct spoolss_ConfigurePort),
31171                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
31172                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
31173                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
31174                 false,
31175         },
31176         {
31177                 "spoolss_DeletePort",
31178                 sizeof(struct spoolss_DeletePort),
31179                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
31180                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
31181                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
31182                 false,
31183         },
31184         {
31185                 "spoolss_CreatePrinterIC",
31186                 sizeof(struct spoolss_CreatePrinterIC),
31187                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
31188                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
31189                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
31190                 false,
31191         },
31192         {
31193                 "spoolss_PlayGDIScriptOnPrinterIC",
31194                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
31195                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
31196                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
31197                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
31198                 false,
31199         },
31200         {
31201                 "spoolss_DeletePrinterIC",
31202                 sizeof(struct spoolss_DeletePrinterIC),
31203                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
31204                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
31205                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
31206                 false,
31207         },
31208         {
31209                 "spoolss_AddPrinterConnection",
31210                 sizeof(struct spoolss_AddPrinterConnection),
31211                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
31212                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
31213                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
31214                 false,
31215         },
31216         {
31217                 "spoolss_DeletePrinterConnection",
31218                 sizeof(struct spoolss_DeletePrinterConnection),
31219                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
31220                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
31221                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
31222                 false,
31223         },
31224         {
31225                 "spoolss_PrinterMessageBox",
31226                 sizeof(struct spoolss_PrinterMessageBox),
31227                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
31228                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
31229                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
31230                 false,
31231         },
31232         {
31233                 "spoolss_AddMonitor",
31234                 sizeof(struct spoolss_AddMonitor),
31235                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
31236                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
31237                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
31238                 false,
31239         },
31240         {
31241                 "spoolss_DeleteMonitor",
31242                 sizeof(struct spoolss_DeleteMonitor),
31243                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
31244                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
31245                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
31246                 false,
31247         },
31248         {
31249                 "spoolss_DeletePrintProcessor",
31250                 sizeof(struct spoolss_DeletePrintProcessor),
31251                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
31252                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
31253                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
31254                 false,
31255         },
31256         {
31257                 "spoolss_AddPrintProvidor",
31258                 sizeof(struct spoolss_AddPrintProvidor),
31259                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
31260                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
31261                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
31262                 false,
31263         },
31264         {
31265                 "spoolss_DeletePrintProvidor",
31266                 sizeof(struct spoolss_DeletePrintProvidor),
31267                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
31268                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
31269                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
31270                 false,
31271         },
31272         {
31273                 "spoolss_EnumPrintProcDataTypes",
31274                 sizeof(struct spoolss_EnumPrintProcDataTypes),
31275                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
31276                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
31277                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
31278                 false,
31279         },
31280         {
31281                 "spoolss_ResetPrinter",
31282                 sizeof(struct spoolss_ResetPrinter),
31283                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
31284                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
31285                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
31286                 false,
31287         },
31288         {
31289                 "spoolss_GetPrinterDriver2",
31290                 sizeof(struct spoolss_GetPrinterDriver2),
31291                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
31292                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
31293                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
31294                 false,
31295         },
31296         {
31297                 "spoolss_FindFirstPrinterChangeNotification",
31298                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
31299                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
31300                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
31301                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
31302                 false,
31303         },
31304         {
31305                 "spoolss_FindNextPrinterChangeNotification",
31306                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
31307                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
31308                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
31309                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
31310                 false,
31311         },
31312         {
31313                 "spoolss_FindClosePrinterNotify",
31314                 sizeof(struct spoolss_FindClosePrinterNotify),
31315                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
31316                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
31317                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
31318                 false,
31319         },
31320         {
31321                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
31322                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
31323                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31324                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31325                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
31326                 false,
31327         },
31328         {
31329                 "spoolss_ReplyOpenPrinter",
31330                 sizeof(struct spoolss_ReplyOpenPrinter),
31331                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
31332                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
31333                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
31334                 false,
31335         },
31336         {
31337                 "spoolss_RouterReplyPrinter",
31338                 sizeof(struct spoolss_RouterReplyPrinter),
31339                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
31340                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
31341                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
31342                 false,
31343         },
31344         {
31345                 "spoolss_ReplyClosePrinter",
31346                 sizeof(struct spoolss_ReplyClosePrinter),
31347                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
31348                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
31349                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
31350                 false,
31351         },
31352         {
31353                 "spoolss_AddPortEx",
31354                 sizeof(struct spoolss_AddPortEx),
31355                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
31356                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
31357                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
31358                 false,
31359         },
31360         {
31361                 "spoolss_RouterFindFirstPrinterChangeNotification",
31362                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
31363                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
31364                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
31365                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
31366                 false,
31367         },
31368         {
31369                 "spoolss_SpoolerInit",
31370                 sizeof(struct spoolss_SpoolerInit),
31371                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
31372                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
31373                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
31374                 false,
31375         },
31376         {
31377                 "spoolss_ResetPrinterEx",
31378                 sizeof(struct spoolss_ResetPrinterEx),
31379                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
31380                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
31381                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
31382                 false,
31383         },
31384         {
31385                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
31386                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
31387                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31388                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31389                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
31390                 false,
31391         },
31392         {
31393                 "spoolss_RouterReplyPrinterEx",
31394                 sizeof(struct spoolss_RouterReplyPrinterEx),
31395                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
31396                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
31397                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
31398                 false,
31399         },
31400         {
31401                 "spoolss_RouterRefreshPrinterChangeNotify",
31402                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
31403                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
31404                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
31405                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
31406                 false,
31407         },
31408         {
31409                 "spoolss_44",
31410                 sizeof(struct spoolss_44),
31411                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
31412                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
31413                 (ndr_print_function_t) ndr_print_spoolss_44,
31414                 false,
31415         },
31416         {
31417                 "spoolss_OpenPrinterEx",
31418                 sizeof(struct spoolss_OpenPrinterEx),
31419                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
31420                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
31421                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
31422                 false,
31423         },
31424         {
31425                 "spoolss_AddPrinterEx",
31426                 sizeof(struct spoolss_AddPrinterEx),
31427                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
31428                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
31429                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
31430                 false,
31431         },
31432         {
31433                 "spoolss_47",
31434                 sizeof(struct spoolss_47),
31435                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
31436                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
31437                 (ndr_print_function_t) ndr_print_spoolss_47,
31438                 false,
31439         },
31440         {
31441                 "spoolss_EnumPrinterData",
31442                 sizeof(struct spoolss_EnumPrinterData),
31443                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
31444                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
31445                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
31446                 false,
31447         },
31448         {
31449                 "spoolss_DeletePrinterData",
31450                 sizeof(struct spoolss_DeletePrinterData),
31451                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
31452                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
31453                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
31454                 false,
31455         },
31456         {
31457                 "spoolss_4a",
31458                 sizeof(struct spoolss_4a),
31459                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
31460                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
31461                 (ndr_print_function_t) ndr_print_spoolss_4a,
31462                 false,
31463         },
31464         {
31465                 "spoolss_4b",
31466                 sizeof(struct spoolss_4b),
31467                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
31468                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
31469                 (ndr_print_function_t) ndr_print_spoolss_4b,
31470                 false,
31471         },
31472         {
31473                 "spoolss_4c",
31474                 sizeof(struct spoolss_4c),
31475                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
31476                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
31477                 (ndr_print_function_t) ndr_print_spoolss_4c,
31478                 false,
31479         },
31480         {
31481                 "spoolss_SetPrinterDataEx",
31482                 sizeof(struct spoolss_SetPrinterDataEx),
31483                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
31484                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
31485                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
31486                 false,
31487         },
31488         {
31489                 "spoolss_GetPrinterDataEx",
31490                 sizeof(struct spoolss_GetPrinterDataEx),
31491                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
31492                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
31493                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
31494                 false,
31495         },
31496         {
31497                 "spoolss_EnumPrinterDataEx",
31498                 sizeof(struct spoolss_EnumPrinterDataEx),
31499                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
31500                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
31501                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
31502                 false,
31503         },
31504         {
31505                 "spoolss_EnumPrinterKey",
31506                 sizeof(struct spoolss_EnumPrinterKey),
31507                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31508                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31509                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31510                 false,
31511         },
31512         {
31513                 "spoolss_DeletePrinterDataEx",
31514                 sizeof(struct spoolss_DeletePrinterDataEx),
31515                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31516                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31517                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31518                 false,
31519         },
31520         {
31521                 "spoolss_DeletePrinterKey",
31522                 sizeof(struct spoolss_DeletePrinterKey),
31523                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31524                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31525                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31526                 false,
31527         },
31528         {
31529                 "spoolss_53",
31530                 sizeof(struct spoolss_53),
31531                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31532                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31533                 (ndr_print_function_t) ndr_print_spoolss_53,
31534                 false,
31535         },
31536         {
31537                 "spoolss_DeletePrinterDriverEx",
31538                 sizeof(struct spoolss_DeletePrinterDriverEx),
31539                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31540                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31541                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31542                 false,
31543         },
31544         {
31545                 "spoolss_55",
31546                 sizeof(struct spoolss_55),
31547                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31548                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31549                 (ndr_print_function_t) ndr_print_spoolss_55,
31550                 false,
31551         },
31552         {
31553                 "spoolss_56",
31554                 sizeof(struct spoolss_56),
31555                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31556                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31557                 (ndr_print_function_t) ndr_print_spoolss_56,
31558                 false,
31559         },
31560         {
31561                 "spoolss_57",
31562                 sizeof(struct spoolss_57),
31563                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31564                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31565                 (ndr_print_function_t) ndr_print_spoolss_57,
31566                 false,
31567         },
31568         {
31569                 "spoolss_XcvData",
31570                 sizeof(struct spoolss_XcvData),
31571                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31572                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31573                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31574                 false,
31575         },
31576         {
31577                 "spoolss_AddPrinterDriverEx",
31578                 sizeof(struct spoolss_AddPrinterDriverEx),
31579                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31580                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31581                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31582                 false,
31583         },
31584         {
31585                 "spoolss_5a",
31586                 sizeof(struct spoolss_5a),
31587                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31588                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31589                 (ndr_print_function_t) ndr_print_spoolss_5a,
31590                 false,
31591         },
31592         {
31593                 "spoolss_5b",
31594                 sizeof(struct spoolss_5b),
31595                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31596                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31597                 (ndr_print_function_t) ndr_print_spoolss_5b,
31598                 false,
31599         },
31600         {
31601                 "spoolss_5c",
31602                 sizeof(struct spoolss_5c),
31603                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31604                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31605                 (ndr_print_function_t) ndr_print_spoolss_5c,
31606                 false,
31607         },
31608         {
31609                 "spoolss_5d",
31610                 sizeof(struct spoolss_5d),
31611                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31612                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31613                 (ndr_print_function_t) ndr_print_spoolss_5d,
31614                 false,
31615         },
31616         {
31617                 "spoolss_5e",
31618                 sizeof(struct spoolss_5e),
31619                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31620                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31621                 (ndr_print_function_t) ndr_print_spoolss_5e,
31622                 false,
31623         },
31624         {
31625                 "spoolss_5f",
31626                 sizeof(struct spoolss_5f),
31627                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31628                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31629                 (ndr_print_function_t) ndr_print_spoolss_5f,
31630                 false,
31631         },
31632         {
31633                 "spoolss_60",
31634                 sizeof(struct spoolss_60),
31635                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31636                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31637                 (ndr_print_function_t) ndr_print_spoolss_60,
31638                 false,
31639         },
31640         {
31641                 "spoolss_61",
31642                 sizeof(struct spoolss_61),
31643                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31644                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31645                 (ndr_print_function_t) ndr_print_spoolss_61,
31646                 false,
31647         },
31648         {
31649                 "spoolss_62",
31650                 sizeof(struct spoolss_62),
31651                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31652                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31653                 (ndr_print_function_t) ndr_print_spoolss_62,
31654                 false,
31655         },
31656         {
31657                 "spoolss_63",
31658                 sizeof(struct spoolss_63),
31659                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31660                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31661                 (ndr_print_function_t) ndr_print_spoolss_63,
31662                 false,
31663         },
31664         {
31665                 "spoolss_64",
31666                 sizeof(struct spoolss_64),
31667                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31668                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31669                 (ndr_print_function_t) ndr_print_spoolss_64,
31670                 false,
31671         },
31672         {
31673                 "spoolss_65",
31674                 sizeof(struct spoolss_65),
31675                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31676                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31677                 (ndr_print_function_t) ndr_print_spoolss_65,
31678                 false,
31679         },
31680         {
31681                 "spoolss_GetCorePrinterDrivers",
31682                 sizeof(struct spoolss_GetCorePrinterDrivers),
31683                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31684                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31685                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31686                 false,
31687         },
31688         {
31689                 "spoolss_67",
31690                 sizeof(struct spoolss_67),
31691                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31692                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31693                 (ndr_print_function_t) ndr_print_spoolss_67,
31694                 false,
31695         },
31696         {
31697                 "spoolss_GetPrinterDriverPackagePath",
31698                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31699                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31700                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31701                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31702                 false,
31703         },
31704         {
31705                 "spoolss_69",
31706                 sizeof(struct spoolss_69),
31707                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31708                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31709                 (ndr_print_function_t) ndr_print_spoolss_69,
31710                 false,
31711         },
31712         {
31713                 "spoolss_6a",
31714                 sizeof(struct spoolss_6a),
31715                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31716                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31717                 (ndr_print_function_t) ndr_print_spoolss_6a,
31718                 false,
31719         },
31720         {
31721                 "spoolss_6b",
31722                 sizeof(struct spoolss_6b),
31723                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31724                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31725                 (ndr_print_function_t) ndr_print_spoolss_6b,
31726                 false,
31727         },
31728         {
31729                 "spoolss_6c",
31730                 sizeof(struct spoolss_6c),
31731                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31732                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31733                 (ndr_print_function_t) ndr_print_spoolss_6c,
31734                 false,
31735         },
31736         {
31737                 "spoolss_6d",
31738                 sizeof(struct spoolss_6d),
31739                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31740                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31741                 (ndr_print_function_t) ndr_print_spoolss_6d,
31742                 false,
31743         },
31744         { NULL, 0, NULL, NULL, NULL, false }
31745 };
31746
31747 static const char * const spoolss_endpoint_strings[] = {
31748         "ncacn_np:[\\pipe\\spoolss]",
31749 };
31750
31751 static const struct ndr_interface_string_array spoolss_endpoints = {
31752         .count  = 1,
31753         .names  = spoolss_endpoint_strings
31754 };
31755
31756 static const char * const spoolss_authservice_strings[] = {
31757         "host",
31758 };
31759
31760 static const struct ndr_interface_string_array spoolss_authservices = {
31761         .count  = 1,
31762         .names  = spoolss_authservice_strings
31763 };
31764
31765
31766 const struct ndr_interface_table ndr_table_spoolss = {
31767         .name           = "spoolss",
31768         .syntax_id      = {
31769                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31770                 NDR_SPOOLSS_VERSION
31771         },
31772         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31773         .num_calls      = 110,
31774         .calls          = spoolss_calls,
31775         .endpoints      = &spoolss_endpoints,
31776         .authservices   = &spoolss_authservices
31777 };
31778