librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21                 NDR_CHECK(ndr_push_trailer_align(ndr, 2));
  22         }
  23         if (ndr_flags & NDR_BUFFERS) {
  24         }
  25         return NDR_ERR_SUCCESS;
  26 }
  27
  28 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  29 {
  30         if (ndr_flags & NDR_SCALARS) {
  31                 NDR_CHECK(ndr_pull_align(ndr, 2));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  39                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  40                 NDR_CHECK(ndr_pull_trailer_align(ndr, 2));
  41         }
  42         if (ndr_flags & NDR_BUFFERS) {
  43         }
  44         return NDR_ERR_SUCCESS;
  45 }
  46
  47 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  48 {
  49         ndr_print_struct(ndr, name, "spoolss_Time");
  50         ndr->depth++;
  51         ndr_print_uint16(ndr, "year", r->year);
  52         ndr_print_uint16(ndr, "month", r->month);
  53         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  54         ndr_print_uint16(ndr, "day", r->day);
  55         ndr_print_uint16(ndr, "hour", r->hour);
  56         ndr_print_uint16(ndr, "minute", r->minute);
  57         ndr_print_uint16(ndr, "second", r->second);
  58         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  59         ndr->depth--;
  60 }
  61
  62 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  63 {
  64         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  65 }
  66
  67 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  68 {
  69         if (ndr_flags & NDR_SCALARS) {
  70                 NDR_CHECK(ndr_push_align(ndr, 5));
  71                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  72                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  73                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
  74         }
  75         if (ndr_flags & NDR_BUFFERS) {
  76                 if (r->time) {
  77                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  78                 }
  79         }
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  84 {
  85         uint32_t _ptr_time;
  86         TALLOC_CTX *_mem_save_time_0;
  87         if (ndr_flags & NDR_SCALARS) {
  88                 NDR_CHECK(ndr_pull_align(ndr, 5));
  89                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  90                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  91                 if (_ptr_time) {
  92                         NDR_PULL_ALLOC(ndr, r->time);
  93                 } else {
  94                         r->time = NULL;
  95                 }
  96                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
  97         }
  98         if (ndr_flags & NDR_BUFFERS) {
  99                 if (r->time) {
 100                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
 101                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
 102                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
 103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 104                 }
 105         }
 106         return NDR_ERR_SUCCESS;
 107 }
 108
 109 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 110 {
 111         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 112         ndr->depth++;
 113         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 114         ndr_print_ptr(ndr, "time", r->time);
 115         ndr->depth++;
 116         if (r->time) {
 117                 ndr_print_spoolss_Time(ndr, "time", r->time);
 118         }
 119         ndr->depth--;
 120         ndr->depth--;
 121 }
 122
 123 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 124 {
 125         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 130 {
 131         uint16_t v;
 132         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
 133         *r = v;
 134         return NDR_ERR_SUCCESS;
 135 }
 136
 137 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 138 {
 139         const char *val = NULL;
 140
 141         switch (r) {
 142                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 143                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 144                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 145         }
 146         ndr_print_enum(ndr, name, "ENUM", val, r);
 147 }
 148
 149 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 150 {
 151         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 152         return NDR_ERR_SUCCESS;
 153 }
 154
 155 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 156 {
 157         uint32_t v;
 158         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 159         *r = v;
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 164 {
 165         const char *val = NULL;
 166
 167         switch (r) {
 168                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 169                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 170                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 171                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 172                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 173         }
 174         ndr_print_enum(ndr, name, "ENUM", val, r);
 175 }
 176
 177 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 178 {
 179         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 184 {
 185         uint32_t v;
 186         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 187         *r = v;
 188         return NDR_ERR_SUCCESS;
 189 }
 190
 191 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 192 {
 193         const char *val = NULL;
 194
 195         switch (r) {
 196                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 197                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 198                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 199         }
 200         ndr_print_enum(ndr, name, "ENUM", val, r);
 201 }
 202
 203 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 204 {
 205         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 210 {
 211         uint32_t v;
 212         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 213         *r = v;
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 218 {
 219         const char *val = NULL;
 220
 221         switch (r) {
 222                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 223                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 224                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 225                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 226                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 227         }
 228         ndr_print_enum(ndr, name, "ENUM", val, r);
 229 }
 230
 231 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 232 {
 233         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 238 {
 239         uint32_t v;
 240         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 241         *r = v;
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 246 {
 247         ndr_print_uint32(ndr, name, r);
 248         ndr->depth++;
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 274         ndr->depth--;
 275 }
 276
 277 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 278 {
 279         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 280         return NDR_ERR_SUCCESS;
 281 }
 282
 283 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 284 {
 285         uint32_t v;
 286         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 287         *r = v;
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 292 {
 293         ndr_print_uint32(ndr, name, r);
 294         ndr->depth++;
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 304         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 305         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 307         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 308         ndr->depth--;
 309 }
 310
 311 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 312 {
 313         if (ndr_flags & NDR_SCALARS) {
 314                 NDR_CHECK(ndr_push_align(ndr, 5));
 315                 {
 316                         uint32_t _flags_save_string = ndr->flags;
 317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 319                         ndr->flags = _flags_save_string;
 320                 }
 321                 {
 322                         uint32_t _flags_save_string = ndr->flags;
 323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 325                         ndr->flags = _flags_save_string;
 326                 }
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 330                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 340                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 342                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 345                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 346                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 349                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 350                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 354                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 355         }
 356         if (ndr_flags & NDR_BUFFERS) {
 357                 {
 358                         uint32_t _flags_save_string = ndr->flags;
 359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 360                         if (r->printername) {
 361                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 362                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 363                         }
 364                         ndr->flags = _flags_save_string;
 365                 }
 366                 {
 367                         uint32_t _flags_save_string = ndr->flags;
 368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 369                         if (r->servername) {
 370                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 371                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 372                         }
 373                         ndr->flags = _flags_save_string;
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 380 {
 381         uint32_t _ptr_printername;
 382         TALLOC_CTX *_mem_save_printername_0;
 383         uint32_t _ptr_servername;
 384         TALLOC_CTX *_mem_save_servername_0;
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_align(ndr, 5));
 387                 {
 388                         uint32_t _flags_save_string = ndr->flags;
 389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 391                         if (_ptr_printername) {
 392                                 NDR_PULL_ALLOC(ndr, r->printername);
 393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 394                         } else {
 395                                 r->printername = NULL;
 396                         }
 397                         ndr->flags = _flags_save_string;
 398                 }
 399                 {
 400                         uint32_t _flags_save_string = ndr->flags;
 401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 403                         if (_ptr_servername) {
 404                                 NDR_PULL_ALLOC(ndr, r->servername);
 405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 406                         } else {
 407                                 r->servername = NULL;
 408                         }
 409                         ndr->flags = _flags_save_string;
 410                 }
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 414                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 424                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 426                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 430                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 433                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 434                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 438                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 439         }
 440         if (ndr_flags & NDR_BUFFERS) {
 441                 {
 442                         uint32_t _flags_save_string = ndr->flags;
 443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 444                         if (r->printername) {
 445                                 uint32_t _relative_save_offset;
 446                                 _relative_save_offset = ndr->offset;
 447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 448                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 449                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 452                                 if (ndr->offset > ndr->relative_highest_offset) {
 453                                         ndr->relative_highest_offset = ndr->offset;
 454                                 }
 455                                 ndr->offset = _relative_save_offset;
 456                         }
 457                         ndr->flags = _flags_save_string;
 458                 }
 459                 {
 460                         uint32_t _flags_save_string = ndr->flags;
 461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 462                         if (r->servername) {
 463                                 uint32_t _relative_save_offset;
 464                                 _relative_save_offset = ndr->offset;
 465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 466                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 467                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 470                                 if (ndr->offset > ndr->relative_highest_offset) {
 471                                         ndr->relative_highest_offset = ndr->offset;
 472                                 }
 473                                 ndr->offset = _relative_save_offset;
 474                         }
 475                         ndr->flags = _flags_save_string;
 476                 }
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 482 {
 483         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 484         ndr->depth++;
 485         ndr_print_ptr(ndr, "printername", r->printername);
 486         ndr->depth++;
 487         if (r->printername) {
 488                 ndr_print_string(ndr, "printername", r->printername);
 489         }
 490         ndr->depth--;
 491         ndr_print_ptr(ndr, "servername", r->servername);
 492         ndr->depth++;
 493         if (r->servername) {
 494                 ndr_print_string(ndr, "servername", r->servername);
 495         }
 496         ndr->depth--;
 497         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 498         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 499         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 500         ndr_print_spoolss_Time(ndr, "time", &r->time);
 501         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 502         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 503         ndr_print_uint32(ndr, "version", r->version);
 504         ndr_print_uint32(ndr, "free_build", r->free_build);
 505         ndr_print_uint32(ndr, "spooling", r->spooling);
 506         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 507         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 508         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 509         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 510         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 511         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 512         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 513         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 514         ndr_print_uint32(ndr, "change_id", r->change_id);
 515         ndr_print_WERROR(ndr, "last_error", r->last_error);
 516         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 517         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 518         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 519         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 520         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 521         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 522         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 523         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 524         ndr->depth--;
 525 }
 526
 527 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 528 {
 529         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 530 }
 531
 532 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 533 {
 534         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 535         return NDR_ERR_SUCCESS;
 536 }
 537
 538 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 539 {
 540         uint32_t v;
 541         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 542         *r = v;
 543         return NDR_ERR_SUCCESS;
 544 }
 545
 546 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 547 {
 548         ndr_print_uint32(ndr, name, r);
 549         ndr->depth++;
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 566         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 567         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 568         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 569         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 571         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 573         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 574         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 575         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 576         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 577         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 578         ndr->depth--;
 579 }
 580
 581 static enum ndr_err_code ndr_push_spoolss_DeviceModeSpecVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion r)
 582 {
 583         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 static enum ndr_err_code ndr_pull_spoolss_DeviceModeSpecVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeSpecVersion *r)
 588 {
 589         uint16_t v;
 590         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 591         *r = v;
 592         return NDR_ERR_SUCCESS;
 593 }
 594
 595 _PUBLIC_ void ndr_print_spoolss_DeviceModeSpecVersion(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeSpecVersion r)
 596 {
 597         const char *val = NULL;
 598
 599         switch (r) {
 600                 case DMSPEC_NT3: val = "DMSPEC_NT3"; break;
 601                 case DMSPEC_WIN95_98_ME: val = "DMSPEC_WIN95_98_ME"; break;
 602                 case DMSPEC_NT4_AND_ABOVE: val = "DMSPEC_NT4_AND_ABOVE"; break;
 603         }
 604         ndr_print_enum(ndr, name, "ENUM", val, r);
 605 }
 606
 607 static enum ndr_err_code ndr_push_spoolss_DeviceModeOrientation(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation r)
 608 {
 609         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 610         return NDR_ERR_SUCCESS;
 611 }
 612
 613 static enum ndr_err_code ndr_pull_spoolss_DeviceModeOrientation(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeOrientation *r)
 614 {
 615         uint16_t v;
 616         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 617         *r = v;
 618         return NDR_ERR_SUCCESS;
 619 }
 620
 621 _PUBLIC_ void ndr_print_spoolss_DeviceModeOrientation(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeOrientation r)
 622 {
 623         const char *val = NULL;
 624
 625         switch (r) {
 626                 case DMORIENT_PORTRAIT: val = "DMORIENT_PORTRAIT"; break;
 627                 case DMORIENT_LANDSCAPE: val = "DMORIENT_LANDSCAPE"; break;
 628         }
 629         ndr_print_enum(ndr, name, "ENUM", val, r);
 630 }
 631
 632 static enum ndr_err_code ndr_push_spoolss_DeviceModePaperSize(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize r)
 633 {
 634         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 635         return NDR_ERR_SUCCESS;
 636 }
 637
 638 static enum ndr_err_code ndr_pull_spoolss_DeviceModePaperSize(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePaperSize *r)
 639 {
 640         uint16_t v;
 641         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 642         *r = v;
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 _PUBLIC_ void ndr_print_spoolss_DeviceModePaperSize(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePaperSize r)
 647 {
 648         const char *val = NULL;
 649
 650         switch (r) {
 651                 case DMPAPER_LETTER: val = "DMPAPER_LETTER"; break;
 652                 case DMPAPER_LETTERSMALL: val = "DMPAPER_LETTERSMALL"; break;
 653                 case DMPAPER_TABLOID: val = "DMPAPER_TABLOID"; break;
 654                 case DMPAPER_LEDGER: val = "DMPAPER_LEDGER"; break;
 655                 case DMPAPER_LEGAL: val = "DMPAPER_LEGAL"; break;
 656                 case DMPAPER_STATEMENT: val = "DMPAPER_STATEMENT"; break;
 657                 case DMPAPER_EXECUTIVE: val = "DMPAPER_EXECUTIVE"; break;
 658                 case DMPAPER_A3: val = "DMPAPER_A3"; break;
 659                 case DMPAPER_A4: val = "DMPAPER_A4"; break;
 660                 case DMPAPER_A4SMALL: val = "DMPAPER_A4SMALL"; break;
 661                 case DMPAPER_A5: val = "DMPAPER_A5"; break;
 662                 case DMPAPER_B4: val = "DMPAPER_B4"; break;
 663                 case DMPAPER_B5: val = "DMPAPER_B5"; break;
 664                 case DMPAPER_FOLIO: val = "DMPAPER_FOLIO"; break;
 665                 case DMPAPER_QUARTO: val = "DMPAPER_QUARTO"; break;
 666                 case DMPAPER_10X14: val = "DMPAPER_10X14"; break;
 667                 case DMPAPER_11X17: val = "DMPAPER_11X17"; break;
 668                 case DMPAPER_NOTE: val = "DMPAPER_NOTE"; break;
 669                 case DMPAPER_ENV_9: val = "DMPAPER_ENV_9"; break;
 670                 case DMPAPER_ENV_10: val = "DMPAPER_ENV_10"; break;
 671                 case DMPAPER_ENV_11: val = "DMPAPER_ENV_11"; break;
 672                 case DMPAPER_ENV_12: val = "DMPAPER_ENV_12"; break;
 673                 case DMPAPER_ENV_14: val = "DMPAPER_ENV_14"; break;
 674                 case DMPAPER_CSHEET: val = "DMPAPER_CSHEET"; break;
 675                 case DMPAPER_DSHEET: val = "DMPAPER_DSHEET"; break;
 676                 case DMPAPER_ESHEET: val = "DMPAPER_ESHEET"; break;
 677                 case DMPAPER_ENV_DL: val = "DMPAPER_ENV_DL"; break;
 678                 case DMPAPER_ENV_C5: val = "DMPAPER_ENV_C5"; break;
 679                 case DMPAPER_ENV_C3: val = "DMPAPER_ENV_C3"; break;
 680                 case DMPAPER_ENV_C4: val = "DMPAPER_ENV_C4"; break;
 681                 case DMPAPER_ENV_C6: val = "DMPAPER_ENV_C6"; break;
 682                 case DMPAPER_ENV_C65: val = "DMPAPER_ENV_C65"; break;
 683                 case DMPAPER_ENV_B4: val = "DMPAPER_ENV_B4"; break;
 684                 case DMPAPER_ENV_B5: val = "DMPAPER_ENV_B5"; break;
 685                 case DMPAPER_ENV_B6: val = "DMPAPER_ENV_B6"; break;
 686                 case DMPAPER_ENV_ITALY: val = "DMPAPER_ENV_ITALY"; break;
 687                 case DMPAPER_ENV_MONARCH: val = "DMPAPER_ENV_MONARCH"; break;
 688                 case DMPAPER_ENV_PERSONAL: val = "DMPAPER_ENV_PERSONAL"; break;
 689                 case DMPAPER_FANFOLD_US: val = "DMPAPER_FANFOLD_US"; break;
 690                 case DMPAPER_FANFOLD_STD_GERMAN: val = "DMPAPER_FANFOLD_STD_GERMAN"; break;
 691                 case DMPAPER_FANFOLD_LGL_GERMAN: val = "DMPAPER_FANFOLD_LGL_GERMAN"; break;
 692                 case DMPAPER_DBL_JAPANESE_POSTCARD: val = "DMPAPER_DBL_JAPANESE_POSTCARD"; break;
 693                 case DMPAPER_A6: val = "DMPAPER_A6"; break;
 694                 case DMPAPER_JENV_KAKU2: val = "DMPAPER_JENV_KAKU2"; break;
 695                 case DMPAPER_JENV_KAKU3: val = "DMPAPER_JENV_KAKU3"; break;
 696                 case DMPAPER_JENV_CHOU3: val = "DMPAPER_JENV_CHOU3"; break;
 697                 case DMPAPER_JENV_CHOU4: val = "DMPAPER_JENV_CHOU4"; break;
 698                 case DMPAPER_LETTER_ROTATED: val = "DMPAPER_LETTER_ROTATED"; break;
 699                 case DMPAPER_A3_ROTATED: val = "DMPAPER_A3_ROTATED"; break;
 700                 case DMPAPER_A4_ROTATED: val = "DMPAPER_A4_ROTATED"; break;
 701                 case DMPAPER_A5_ROTATED: val = "DMPAPER_A5_ROTATED"; break;
 702                 case DMPAPER_B4_JIS_ROTATED: val = "DMPAPER_B4_JIS_ROTATED"; break;
 703                 case DMPAPER_B5_JIS_ROTATED: val = "DMPAPER_B5_JIS_ROTATED"; break;
 704                 case DMPAPER_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_JAPANESE_POSTCARD_ROTATED"; break;
 705                 case DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED: val = "DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED"; break;
 706                 case DMPAPER_A6_ROTATED: val = "DMPAPER_A6_ROTATED"; break;
 707                 case DMPAPER_JENV_KAKU2_ROTATED: val = "DMPAPER_JENV_KAKU2_ROTATED"; break;
 708                 case DMPAPER_JENV_KAKU3_ROTATED: val = "DMPAPER_JENV_KAKU3_ROTATED"; break;
 709                 case DMPAPER_JENV_CHOU3_ROTATED: val = "DMPAPER_JENV_CHOU3_ROTATED"; break;
 710                 case DMPAPER_JENV_CHOU4_ROTATED: val = "DMPAPER_JENV_CHOU4_ROTATED"; break;
 711                 case DMPAPER_B6_JIS: val = "DMPAPER_B6_JIS"; break;
 712                 case DMPAPER_B6_JIS_ROTATED: val = "DMPAPER_B6_JIS_ROTATED"; break;
 713                 case DMPAPER_12X11: val = "DMPAPER_12X11"; break;
 714                 case DMPAPER_JENV_YOU4: val = "DMPAPER_JENV_YOU4"; break;
 715                 case DMPAPER_JENV_YOU4_ROTATED: val = "DMPAPER_JENV_YOU4_ROTATED"; break;
 716                 case DMPAPER_P16K: val = "DMPAPER_P16K"; break;
 717                 case DMPAPER_P32K: val = "DMPAPER_P32K"; break;
 718                 case DMPAPER_P32KBIG: val = "DMPAPER_P32KBIG"; break;
 719                 case DMPAPER_PENV_1: val = "DMPAPER_PENV_1"; break;
 720                 case DMPAPER_PENV_2: val = "DMPAPER_PENV_2"; break;
 721                 case DMPAPER_PENV_3: val = "DMPAPER_PENV_3"; break;
 722                 case DMPAPER_PENV_4: val = "DMPAPER_PENV_4"; break;
 723                 case DMPAPER_PENV_5: val = "DMPAPER_PENV_5"; break;
 724                 case DMPAPER_PENV_6: val = "DMPAPER_PENV_6"; break;
 725                 case DMPAPER_PENV_7: val = "DMPAPER_PENV_7"; break;
 726                 case DMPAPER_PENV_8: val = "DMPAPER_PENV_8"; break;
 727                 case DMPAPER_PENV_9: val = "DMPAPER_PENV_9"; break;
 728                 case DMPAPER_PENV_10: val = "DMPAPER_PENV_10"; break;
 729                 case DMPAPER_P16K_ROTATED: val = "DMPAPER_P16K_ROTATED"; break;
 730                 case DMPAPER_P32K_ROTATED: val = "DMPAPER_P32K_ROTATED"; break;
 731                 case DMPAPER_P32KBIG_ROTATED: val = "DMPAPER_P32KBIG_ROTATED"; break;
 732                 case DMPAPER_PENV_1_ROTATED: val = "DMPAPER_PENV_1_ROTATED"; break;
 733                 case DMPAPER_PENV_2_ROTATED: val = "DMPAPER_PENV_2_ROTATED"; break;
 734                 case DMPAPER_PENV_3_ROTATED: val = "DMPAPER_PENV_3_ROTATED"; break;
 735                 case DMPAPER_PENV_4_ROTATED: val = "DMPAPER_PENV_4_ROTATED"; break;
 736                 case DMPAPER_PENV_5_ROTATED: val = "DMPAPER_PENV_5_ROTATED"; break;
 737                 case DMPAPER_PENV_6_ROTATED: val = "DMPAPER_PENV_6_ROTATED"; break;
 738                 case DMPAPER_PENV_7_ROTATED: val = "DMPAPER_PENV_7_ROTATED"; break;
 739                 case DMPAPER_PENV_8_ROTATED: val = "DMPAPER_PENV_8_ROTATED"; break;
 740                 case DMPAPER_PENV_9_ROTATED: val = "DMPAPER_PENV_9_ROTATED"; break;
 741                 case DMPAPER_PENV_10_ROTATED: val = "DMPAPER_PENV_10_ROTATED"; break;
 742         }
 743         ndr_print_enum(ndr, name, "ENUM", val, r);
 744 }
 745
 746 static enum ndr_err_code ndr_push_spoolss_DeviceModeDefaultSource(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource r)
 747 {
 748         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 749         return NDR_ERR_SUCCESS;
 750 }
 751
 752 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDefaultSource(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDefaultSource *r)
 753 {
 754         uint16_t v;
 755         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 756         *r = v;
 757         return NDR_ERR_SUCCESS;
 758 }
 759
 760 _PUBLIC_ void ndr_print_spoolss_DeviceModeDefaultSource(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDefaultSource r)
 761 {
 762         const char *val = NULL;
 763
 764         switch (r) {
 765                 case DMBIN_UPPER: val = "DMBIN_UPPER"; break;
 766                 case DMBIN_LOWER: val = "DMBIN_LOWER"; break;
 767                 case DMBIN_MIDDLE: val = "DMBIN_MIDDLE"; break;
 768                 case DMBIN_MANUAL: val = "DMBIN_MANUAL"; break;
 769                 case DMBIN_ENVELOPE: val = "DMBIN_ENVELOPE"; break;
 770                 case DMBIN_ENVMANUAL: val = "DMBIN_ENVMANUAL"; break;
 771                 case DMBIN_AUTO: val = "DMBIN_AUTO"; break;
 772                 case DMBIN_TRACTOR: val = "DMBIN_TRACTOR"; break;
 773                 case DMBIN_SMALLFMT: val = "DMBIN_SMALLFMT"; break;
 774                 case DMBIN_LARGEFMT: val = "DMBIN_LARGEFMT"; break;
 775                 case DMBIN_LARGECAPACITY: val = "DMBIN_LARGECAPACITY"; break;
 776                 case DMBIN_CASSETTE: val = "DMBIN_CASSETTE"; break;
 777                 case DMBIN_FORMSOURCE: val = "DMBIN_FORMSOURCE"; break;
 778         }
 779         ndr_print_enum(ndr, name, "ENUM", val, r);
 780 }
 781
 782 static enum ndr_err_code ndr_push_spoolss_DeviceModePrintQuality(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality r)
 783 {
 784         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 785         return NDR_ERR_SUCCESS;
 786 }
 787
 788 static enum ndr_err_code ndr_pull_spoolss_DeviceModePrintQuality(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModePrintQuality *r)
 789 {
 790         uint16_t v;
 791         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 792         *r = v;
 793         return NDR_ERR_SUCCESS;
 794 }
 795
 796 _PUBLIC_ void ndr_print_spoolss_DeviceModePrintQuality(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModePrintQuality r)
 797 {
 798         const char *val = NULL;
 799
 800         switch (r) {
 801                 case DMRES_HIGH: val = "DMRES_HIGH"; break;
 802                 case DMRES_MEDIUM: val = "DMRES_MEDIUM"; break;
 803                 case DMRES_LOW: val = "DMRES_LOW"; break;
 804                 case DMRES_DRAFT: val = "DMRES_DRAFT"; break;
 805         }
 806         ndr_print_enum(ndr, name, "ENUM", val, r);
 807 }
 808
 809 static enum ndr_err_code ndr_push_spoolss_DeviceModeColor(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeColor r)
 810 {
 811         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 812         return NDR_ERR_SUCCESS;
 813 }
 814
 815 static enum ndr_err_code ndr_pull_spoolss_DeviceModeColor(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeColor *r)
 816 {
 817         uint16_t v;
 818         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 819         *r = v;
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_spoolss_DeviceModeColor(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeColor r)
 824 {
 825         const char *val = NULL;
 826
 827         switch (r) {
 828                 case DMRES_MONOCHROME: val = "DMRES_MONOCHROME"; break;
 829                 case DMRES_COLOR: val = "DMRES_COLOR"; break;
 830         }
 831         ndr_print_enum(ndr, name, "ENUM", val, r);
 832 }
 833
 834 static enum ndr_err_code ndr_push_spoolss_DeviceModeDuplex(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex r)
 835 {
 836         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 837         return NDR_ERR_SUCCESS;
 838 }
 839
 840 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDuplex(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDuplex *r)
 841 {
 842         uint16_t v;
 843         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 844         *r = v;
 845         return NDR_ERR_SUCCESS;
 846 }
 847
 848 _PUBLIC_ void ndr_print_spoolss_DeviceModeDuplex(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDuplex r)
 849 {
 850         const char *val = NULL;
 851
 852         switch (r) {
 853                 case DMDUP_SIMPLEX: val = "DMDUP_SIMPLEX"; break;
 854                 case DMDUP_VERTICAL: val = "DMDUP_VERTICAL"; break;
 855                 case DMDUP_HORIZONTAL: val = "DMDUP_HORIZONTAL"; break;
 856         }
 857         ndr_print_enum(ndr, name, "ENUM", val, r);
 858 }
 859
 860 static enum ndr_err_code ndr_push_spoolss_DeviceModeTTOption(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption r)
 861 {
 862         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 863         return NDR_ERR_SUCCESS;
 864 }
 865
 866 static enum ndr_err_code ndr_pull_spoolss_DeviceModeTTOption(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeTTOption *r)
 867 {
 868         uint16_t v;
 869         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 870         *r = v;
 871         return NDR_ERR_SUCCESS;
 872 }
 873
 874 _PUBLIC_ void ndr_print_spoolss_DeviceModeTTOption(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeTTOption r)
 875 {
 876         const char *val = NULL;
 877
 878         switch (r) {
 879                 case DMTT_BITMAP: val = "DMTT_BITMAP"; break;
 880                 case DMTT_DOWNLOAD: val = "DMTT_DOWNLOAD"; break;
 881                 case DMTT_SUBDEV: val = "DMTT_SUBDEV"; break;
 882                 case DMTT_DOWNLOAD_OUTLINE: val = "DMTT_DOWNLOAD_OUTLINE"; break;
 883         }
 884         ndr_print_enum(ndr, name, "ENUM", val, r);
 885 }
 886
 887 static enum ndr_err_code ndr_push_spoolss_DeviceModeCollate(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeCollate r)
 888 {
 889         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
 890         return NDR_ERR_SUCCESS;
 891 }
 892
 893 static enum ndr_err_code ndr_pull_spoolss_DeviceModeCollate(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeCollate *r)
 894 {
 895         uint16_t v;
 896         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
 897         *r = v;
 898         return NDR_ERR_SUCCESS;
 899 }
 900
 901 _PUBLIC_ void ndr_print_spoolss_DeviceModeCollate(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeCollate r)
 902 {
 903         const char *val = NULL;
 904
 905         switch (r) {
 906                 case DMCOLLATE_FALSE: val = "DMCOLLATE_FALSE"; break;
 907                 case DMCOLLATE_TRUE: val = "DMCOLLATE_TRUE"; break;
 908         }
 909         ndr_print_enum(ndr, name, "ENUM", val, r);
 910 }
 911
 912 static enum ndr_err_code ndr_push_spoolss_DeviceModeNUp(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeNUp r)
 913 {
 914         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 915         return NDR_ERR_SUCCESS;
 916 }
 917
 918 static enum ndr_err_code ndr_pull_spoolss_DeviceModeNUp(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeNUp *r)
 919 {
 920         uint32_t v;
 921         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 922         *r = v;
 923         return NDR_ERR_SUCCESS;
 924 }
 925
 926 _PUBLIC_ void ndr_print_spoolss_DeviceModeNUp(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeNUp r)
 927 {
 928         const char *val = NULL;
 929
 930         switch (r) {
 931                 case DMNUP_SYSTEM: val = "DMNUP_SYSTEM"; break;
 932                 case DMNUP_ONEUP: val = "DMNUP_ONEUP"; break;
 933         }
 934         ndr_print_enum(ndr, name, "ENUM", val, r);
 935 }
 936
 937 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMMethod(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod r)
 938 {
 939         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 940         return NDR_ERR_SUCCESS;
 941 }
 942
 943 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMMethod(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMMethod *r)
 944 {
 945         uint32_t v;
 946         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 947         *r = v;
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMMethod(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMMethod r)
 952 {
 953         const char *val = NULL;
 954
 955         switch (r) {
 956                 case DMICMMETHOD_NONE: val = "DMICMMETHOD_NONE"; break;
 957                 case DMICMMETHOD_SYSTEM: val = "DMICMMETHOD_SYSTEM"; break;
 958                 case DMICMMETHOD_DRIVER: val = "DMICMMETHOD_DRIVER"; break;
 959                 case DMICMMETHOD_DEVICE: val = "DMICMMETHOD_DEVICE"; break;
 960         }
 961         ndr_print_enum(ndr, name, "ENUM", val, r);
 962 }
 963
 964 static enum ndr_err_code ndr_push_spoolss_DeviceModeICMIntent(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent r)
 965 {
 966         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 967         return NDR_ERR_SUCCESS;
 968 }
 969
 970 static enum ndr_err_code ndr_pull_spoolss_DeviceModeICMIntent(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeICMIntent *r)
 971 {
 972         uint32_t v;
 973         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 974         *r = v;
 975         return NDR_ERR_SUCCESS;
 976 }
 977
 978 _PUBLIC_ void ndr_print_spoolss_DeviceModeICMIntent(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeICMIntent r)
 979 {
 980         const char *val = NULL;
 981
 982         switch (r) {
 983                 case DMICM_SATURATE: val = "DMICM_SATURATE"; break;
 984                 case DMICM_CONTRAST: val = "DMICM_CONTRAST"; break;
 985                 case DMICM_COLORIMETRIC: val = "DMICM_COLORIMETRIC"; break;
 986                 case DMICM_ABS_COLORIMETRIC: val = "DMICM_ABS_COLORIMETRIC"; break;
 987         }
 988         ndr_print_enum(ndr, name, "ENUM", val, r);
 989 }
 990
 991 static enum ndr_err_code ndr_push_spoolss_DeviceModeMediaType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType r)
 992 {
 993         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 static enum ndr_err_code ndr_pull_spoolss_DeviceModeMediaType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeMediaType *r)
 998 {
 999         uint32_t v;
1000         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1001         *r = v;
1002         return NDR_ERR_SUCCESS;
1003 }
1004
1005 _PUBLIC_ void ndr_print_spoolss_DeviceModeMediaType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeMediaType r)
1006 {
1007         const char *val = NULL;
1008
1009         switch (r) {
1010                 case DMMEDIA_STANDARD: val = "DMMEDIA_STANDARD"; break;
1011                 case DMMEDIA_TRANSPARENCY: val = "DMMEDIA_TRANSPARENCY"; break;
1012                 case DMMEDIA_GLOSSY: val = "DMMEDIA_GLOSSY"; break;
1013         }
1014         ndr_print_enum(ndr, name, "ENUM", val, r);
1015 }
1016
1017 static enum ndr_err_code ndr_push_spoolss_DeviceModeDitherType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType r)
1018 {
1019         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1020         return NDR_ERR_SUCCESS;
1021 }
1022
1023 static enum ndr_err_code ndr_pull_spoolss_DeviceModeDitherType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DeviceModeDitherType *r)
1024 {
1025         uint32_t v;
1026         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1027         *r = v;
1028         return NDR_ERR_SUCCESS;
1029 }
1030
1031 _PUBLIC_ void ndr_print_spoolss_DeviceModeDitherType(struct ndr_print *ndr, const char *name, enum spoolss_DeviceModeDitherType r)
1032 {
1033         const char *val = NULL;
1034
1035         switch (r) {
1036                 case DMDITHER_NONE: val = "DMDITHER_NONE"; break;
1037                 case DMDITHER_COARSE: val = "DMDITHER_COARSE"; break;
1038                 case DMDITHER_FINE: val = "DMDITHER_FINE"; break;
1039                 case DMDITHER_LINEART: val = "DMDITHER_LINEART"; break;
1040                 case DMDITHER_ERRORDIFFUSION: val = "DMDITHER_ERRORDIFFUSION"; break;
1041                 case DMDITHER_RESERVED6: val = "DMDITHER_RESERVED6"; break;
1042                 case DMDITHER_RESERVED7: val = "DMDITHER_RESERVED7"; break;
1043                 case DMDITHER_RESERVED8: val = "DMDITHER_RESERVED8"; break;
1044                 case DMDITHER_RESERVED9: val = "DMDITHER_RESERVED9"; break;
1045                 case DMDITHER_GRAYSCALE: val = "DMDITHER_GRAYSCALE"; break;
1046         }
1047         ndr_print_enum(ndr, name, "ENUM", val, r);
1048 }
1049
1050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
1051 {
1052         if (ndr_flags & NDR_SCALARS) {
1053                 NDR_CHECK(ndr_push_align(ndr, 4));
1054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1055                 NDR_CHECK(ndr_push_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, r->specversion));
1056                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
1057                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
1058                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
1059                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
1060                 NDR_CHECK(ndr_push_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, r->orientation));
1061                 NDR_CHECK(ndr_push_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, r->papersize));
1062                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
1063                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
1064                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
1065                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
1066                 NDR_CHECK(ndr_push_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, r->defaultsource));
1067                 NDR_CHECK(ndr_push_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, r->printquality));
1068                 NDR_CHECK(ndr_push_spoolss_DeviceModeColor(ndr, NDR_SCALARS, r->color));
1069                 NDR_CHECK(ndr_push_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, r->duplex));
1070                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
1071                 NDR_CHECK(ndr_push_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, r->ttoption));
1072                 NDR_CHECK(ndr_push_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, r->collate));
1073                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1074                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
1075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
1076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
1077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
1078                 NDR_CHECK(ndr_push_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, r->displayflags));
1079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
1080                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, r->icmmethod));
1081                 NDR_CHECK(ndr_push_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, r->icmintent));
1082                 NDR_CHECK(ndr_push_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, r->mediatype));
1083                 NDR_CHECK(ndr_push_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, r->dithertype));
1084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
1085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
1087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
1088                 {
1089                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1091                         {
1092                                 struct ndr_push *_ndr_driverextra_data;
1093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
1094                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
1095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
1096                         }
1097                         ndr->flags = _flags_save_DATA_BLOB;
1098                 }
1099                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1100         }
1101         if (ndr_flags & NDR_BUFFERS) {
1102         }
1103         return NDR_ERR_SUCCESS;
1104 }
1105
1106 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
1107 {
1108         if (ndr_flags & NDR_SCALARS) {
1109                 NDR_CHECK(ndr_pull_align(ndr, 4));
1110                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1111                 NDR_CHECK(ndr_pull_spoolss_DeviceModeSpecVersion(ndr, NDR_SCALARS, &r->specversion));
1112                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
1113                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
1114                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
1115                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
1116                 NDR_CHECK(ndr_pull_spoolss_DeviceModeOrientation(ndr, NDR_SCALARS, &r->orientation));
1117                 NDR_CHECK(ndr_pull_spoolss_DeviceModePaperSize(ndr, NDR_SCALARS, &r->papersize));
1118                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
1119                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
1120                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
1121                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
1122                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDefaultSource(ndr, NDR_SCALARS, &r->defaultsource));
1123                 NDR_CHECK(ndr_pull_spoolss_DeviceModePrintQuality(ndr, NDR_SCALARS, &r->printquality));
1124                 NDR_CHECK(ndr_pull_spoolss_DeviceModeColor(ndr, NDR_SCALARS, &r->color));
1125                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDuplex(ndr, NDR_SCALARS, &r->duplex));
1126                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
1127                 NDR_CHECK(ndr_pull_spoolss_DeviceModeTTOption(ndr, NDR_SCALARS, &r->ttoption));
1128                 NDR_CHECK(ndr_pull_spoolss_DeviceModeCollate(ndr, NDR_SCALARS, &r->collate));
1129                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, MAXDEVICENAME, sizeof(uint16_t), CH_UTF16));
1130                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
1131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
1132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
1133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
1134                 NDR_CHECK(ndr_pull_spoolss_DeviceModeNUp(ndr, NDR_SCALARS, &r->displayflags));
1135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
1136                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMMethod(ndr, NDR_SCALARS, &r->icmmethod));
1137                 NDR_CHECK(ndr_pull_spoolss_DeviceModeICMIntent(ndr, NDR_SCALARS, &r->icmintent));
1138                 NDR_CHECK(ndr_pull_spoolss_DeviceModeMediaType(ndr, NDR_SCALARS, &r->mediatype));
1139                 NDR_CHECK(ndr_pull_spoolss_DeviceModeDitherType(ndr, NDR_SCALARS, &r->dithertype));
1140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
1143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
1144                 {
1145                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
1146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
1147                         {
1148                                 struct ndr_pull *_ndr_driverextra_data;
1149                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
1150                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
1151                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
1152                         }
1153                         ndr->flags = _flags_save_DATA_BLOB;
1154                 }
1155                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1156         }
1157         if (ndr_flags & NDR_BUFFERS) {
1158         }
1159         return NDR_ERR_SUCCESS;
1160 }
1161
1162 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
1163 {
1164         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
1165         ndr->depth++;
1166         ndr_print_string(ndr, "devicename", r->devicename);
1167         ndr_print_spoolss_DeviceModeSpecVersion(ndr, "specversion", r->specversion);
1168         ndr_print_uint16(ndr, "driverversion", r->driverversion);
1169         ndr_print_uint16(ndr, "size", r->size);
1170         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
1171         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
1172         ndr_print_spoolss_DeviceModeOrientation(ndr, "orientation", r->orientation);
1173         ndr_print_spoolss_DeviceModePaperSize(ndr, "papersize", r->papersize);
1174         ndr_print_uint16(ndr, "paperlength", r->paperlength);
1175         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
1176         ndr_print_uint16(ndr, "scale", r->scale);
1177         ndr_print_uint16(ndr, "copies", r->copies);
1178         ndr_print_spoolss_DeviceModeDefaultSource(ndr, "defaultsource", r->defaultsource);
1179         ndr_print_spoolss_DeviceModePrintQuality(ndr, "printquality", r->printquality);
1180         ndr_print_spoolss_DeviceModeColor(ndr, "color", r->color);
1181         ndr_print_spoolss_DeviceModeDuplex(ndr, "duplex", r->duplex);
1182         ndr_print_uint16(ndr, "yresolution", r->yresolution);
1183         ndr_print_spoolss_DeviceModeTTOption(ndr, "ttoption", r->ttoption);
1184         ndr_print_spoolss_DeviceModeCollate(ndr, "collate", r->collate);
1185         ndr_print_string(ndr, "formname", r->formname);
1186         ndr_print_uint16(ndr, "logpixels", r->logpixels);
1187         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
1188         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
1189         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
1190         ndr_print_spoolss_DeviceModeNUp(ndr, "displayflags", r->displayflags);
1191         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
1192         ndr_print_spoolss_DeviceModeICMMethod(ndr, "icmmethod", r->icmmethod);
1193         ndr_print_spoolss_DeviceModeICMIntent(ndr, "icmintent", r->icmintent);
1194         ndr_print_spoolss_DeviceModeMediaType(ndr, "mediatype", r->mediatype);
1195         ndr_print_spoolss_DeviceModeDitherType(ndr, "dithertype", r->dithertype);
1196         ndr_print_uint32(ndr, "reserved1", r->reserved1);
1197         ndr_print_uint32(ndr, "reserved2", r->reserved2);
1198         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
1199         ndr_print_uint32(ndr, "panningheight", r->panningheight);
1200         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
1201         ndr->depth--;
1202 }
1203
1204 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
1205 {
1206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
1207 }
1208
1209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1210 {
1211         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1212         return NDR_ERR_SUCCESS;
1213 }
1214
1215 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1216 {
1217         uint32_t v;
1218         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1219         *r = v;
1220         return NDR_ERR_SUCCESS;
1221 }
1222
1223 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
1224 {
1225         ndr_print_uint32(ndr, name, r);
1226         ndr->depth++;
1227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
1228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
1229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
1230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
1231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
1232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
1233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
1234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
1235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
1236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
1237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
1238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
1239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
1240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
1241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
1242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
1243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
1244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
1245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
1246         ndr->depth--;
1247 }
1248
1249 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1250 {
1251         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1252         return NDR_ERR_SUCCESS;
1253 }
1254
1255 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1256 {
1257         uint32_t v;
1258         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1259         *r = v;
1260         return NDR_ERR_SUCCESS;
1261 }
1262
1263 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
1264 {
1265         ndr_print_uint32(ndr, name, r);
1266         ndr->depth++;
1267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
1268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
1269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
1270         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
1271         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
1272         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
1273         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
1274         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
1275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
1276         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
1277         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
1278         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
1279         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
1280         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
1281         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
1282         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
1283         ndr->depth--;
1284 }
1285
1286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
1287 {
1288         if (ndr_flags & NDR_SCALARS) {
1289                 NDR_CHECK(ndr_push_align(ndr, 5));
1290                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
1291                 {
1292                         uint32_t _flags_save_string = ndr->flags;
1293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 {
1298                         uint32_t _flags_save_string = ndr->flags;
1299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
1301                         ndr->flags = _flags_save_string;
1302                 }
1303                 {
1304                         uint32_t _flags_save_string = ndr->flags;
1305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1307                         ndr->flags = _flags_save_string;
1308                 }
1309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1310         }
1311         if (ndr_flags & NDR_BUFFERS) {
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         if (r->description) {
1316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
1317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
1318                         }
1319                         ndr->flags = _flags_save_string;
1320                 }
1321                 {
1322                         uint32_t _flags_save_string = ndr->flags;
1323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1324                         if (r->name) {
1325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
1326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
1327                         }
1328                         ndr->flags = _flags_save_string;
1329                 }
1330                 {
1331                         uint32_t _flags_save_string = ndr->flags;
1332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1333                         if (r->comment) {
1334                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1335                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1336                         }
1337                         ndr->flags = _flags_save_string;
1338                 }
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
1344 {
1345         uint32_t _ptr_description;
1346         TALLOC_CTX *_mem_save_description_0;
1347         uint32_t _ptr_name;
1348         TALLOC_CTX *_mem_save_name_0;
1349         uint32_t _ptr_comment;
1350         TALLOC_CTX *_mem_save_comment_0;
1351         if (ndr_flags & NDR_SCALARS) {
1352                 NDR_CHECK(ndr_pull_align(ndr, 5));
1353                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
1354                 {
1355                         uint32_t _flags_save_string = ndr->flags;
1356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1357                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
1358                         if (_ptr_description) {
1359                                 NDR_PULL_ALLOC(ndr, r->description);
1360                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
1361                         } else {
1362                                 r->description = NULL;
1363                         }
1364                         ndr->flags = _flags_save_string;
1365                 }
1366                 {
1367                         uint32_t _flags_save_string = ndr->flags;
1368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1369                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
1370                         if (_ptr_name) {
1371                                 NDR_PULL_ALLOC(ndr, r->name);
1372                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
1373                         } else {
1374                                 r->name = NULL;
1375                         }
1376                         ndr->flags = _flags_save_string;
1377                 }
1378                 {
1379                         uint32_t _flags_save_string = ndr->flags;
1380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1381                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1382                         if (_ptr_comment) {
1383                                 NDR_PULL_ALLOC(ndr, r->comment);
1384                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1385                         } else {
1386                                 r->comment = NULL;
1387                         }
1388                         ndr->flags = _flags_save_string;
1389                 }
1390                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1391         }
1392         if (ndr_flags & NDR_BUFFERS) {
1393                 {
1394                         uint32_t _flags_save_string = ndr->flags;
1395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1396                         if (r->description) {
1397                                 uint32_t _relative_save_offset;
1398                                 _relative_save_offset = ndr->offset;
1399                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
1400                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
1401                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
1402                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
1403                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
1404                                 if (ndr->offset > ndr->relative_highest_offset) {
1405                                         ndr->relative_highest_offset = ndr->offset;
1406                                 }
1407                                 ndr->offset = _relative_save_offset;
1408                         }
1409                         ndr->flags = _flags_save_string;
1410                 }
1411                 {
1412                         uint32_t _flags_save_string = ndr->flags;
1413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1414                         if (r->name) {
1415                                 uint32_t _relative_save_offset;
1416                                 _relative_save_offset = ndr->offset;
1417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
1418                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1419                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
1420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
1421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
1422                                 if (ndr->offset > ndr->relative_highest_offset) {
1423                                         ndr->relative_highest_offset = ndr->offset;
1424                                 }
1425                                 ndr->offset = _relative_save_offset;
1426                         }
1427                         ndr->flags = _flags_save_string;
1428                 }
1429                 {
1430                         uint32_t _flags_save_string = ndr->flags;
1431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1432                         if (r->comment) {
1433                                 uint32_t _relative_save_offset;
1434                                 _relative_save_offset = ndr->offset;
1435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1436                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1437                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1440                                 if (ndr->offset > ndr->relative_highest_offset) {
1441                                         ndr->relative_highest_offset = ndr->offset;
1442                                 }
1443                                 ndr->offset = _relative_save_offset;
1444                         }
1445                         ndr->flags = _flags_save_string;
1446                 }
1447         }
1448         return NDR_ERR_SUCCESS;
1449 }
1450
1451 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
1452 {
1453         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
1454         ndr->depth++;
1455         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
1456         ndr_print_ptr(ndr, "description", r->description);
1457         ndr->depth++;
1458         if (r->description) {
1459                 ndr_print_string(ndr, "description", r->description);
1460         }
1461         ndr->depth--;
1462         ndr_print_ptr(ndr, "name", r->name);
1463         ndr->depth++;
1464         if (r->name) {
1465                 ndr_print_string(ndr, "name", r->name);
1466         }
1467         ndr->depth--;
1468         ndr_print_ptr(ndr, "comment", r->comment);
1469         ndr->depth++;
1470         if (r->comment) {
1471                 ndr_print_string(ndr, "comment", r->comment);
1472         }
1473         ndr->depth--;
1474         ndr->depth--;
1475 }
1476
1477 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
1478 {
1479         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
1480 }
1481
1482 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
1483 {
1484         if (ndr_flags & NDR_SCALARS) {
1485                 NDR_CHECK(ndr_push_align(ndr, 5));
1486                 {
1487                         uint32_t _flags_save_string = ndr->flags;
1488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1490                         ndr->flags = _flags_save_string;
1491                 }
1492                 {
1493                         uint32_t _flags_save_string = ndr->flags;
1494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1496                         ndr->flags = _flags_save_string;
1497                 }
1498                 {
1499                         uint32_t _flags_save_string = ndr->flags;
1500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1502                         ndr->flags = _flags_save_string;
1503                 }
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1508                         ndr->flags = _flags_save_string;
1509                 }
1510                 {
1511                         uint32_t _flags_save_string = ndr->flags;
1512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1514                         ndr->flags = _flags_save_string;
1515                 }
1516                 {
1517                         uint32_t _flags_save_string = ndr->flags;
1518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1520                         ndr->flags = _flags_save_string;
1521                 }
1522                 {
1523                         uint32_t _flags_save_string = ndr->flags;
1524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1526                         ndr->flags = _flags_save_string;
1527                 }
1528                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1529                 {
1530                         uint32_t _flags_save_string = ndr->flags;
1531                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1532                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1533                         ndr->flags = _flags_save_string;
1534                 }
1535                 {
1536                         uint32_t _flags_save_string = ndr->flags;
1537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1538                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1539                         ndr->flags = _flags_save_string;
1540                 }
1541                 {
1542                         uint32_t _flags_save_string = ndr->flags;
1543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1544                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 {
1548                         uint32_t _flags_save_string = ndr->flags;
1549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1550                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1551                         ndr->flags = _flags_save_string;
1552                 }
1553                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1554                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1559                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1562                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1563         }
1564         if (ndr_flags & NDR_BUFFERS) {
1565                 {
1566                         uint32_t _flags_save_string = ndr->flags;
1567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1568                         if (r->servername) {
1569                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1570                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1571                         }
1572                         ndr->flags = _flags_save_string;
1573                 }
1574                 {
1575                         uint32_t _flags_save_string = ndr->flags;
1576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1577                         if (r->printername) {
1578                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1579                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1580                         }
1581                         ndr->flags = _flags_save_string;
1582                 }
1583                 {
1584                         uint32_t _flags_save_string = ndr->flags;
1585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1586                         if (r->sharename) {
1587                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1588                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1589                         }
1590                         ndr->flags = _flags_save_string;
1591                 }
1592                 {
1593                         uint32_t _flags_save_string = ndr->flags;
1594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1595                         if (r->portname) {
1596                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1597                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1598                         }
1599                         ndr->flags = _flags_save_string;
1600                 }
1601                 {
1602                         uint32_t _flags_save_string = ndr->flags;
1603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1604                         if (r->drivername) {
1605                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1606                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1607                         }
1608                         ndr->flags = _flags_save_string;
1609                 }
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         if (r->comment) {
1614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1616                         }
1617                         ndr->flags = _flags_save_string;
1618                 }
1619                 {
1620                         uint32_t _flags_save_string = ndr->flags;
1621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1622                         if (r->location) {
1623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1625                         }
1626                         ndr->flags = _flags_save_string;
1627                 }
1628                 if (r->devmode) {
1629                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1630                         {
1631                                 struct ndr_push *_ndr_devmode;
1632                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1633                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1634                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1635                         }
1636                 }
1637                 {
1638                         uint32_t _flags_save_string = ndr->flags;
1639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1640                         if (r->sepfile) {
1641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1643                         }
1644                         ndr->flags = _flags_save_string;
1645                 }
1646                 {
1647                         uint32_t _flags_save_string = ndr->flags;
1648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1649                         if (r->printprocessor) {
1650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1652                         }
1653                         ndr->flags = _flags_save_string;
1654                 }
1655                 {
1656                         uint32_t _flags_save_string = ndr->flags;
1657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1658                         if (r->datatype) {
1659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1661                         }
1662                         ndr->flags = _flags_save_string;
1663                 }
1664                 {
1665                         uint32_t _flags_save_string = ndr->flags;
1666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1667                         if (r->parameters) {
1668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1669                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1670                         }
1671                         ndr->flags = _flags_save_string;
1672                 }
1673                 if (r->secdesc) {
1674                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1675                         {
1676                                 struct ndr_push *_ndr_secdesc;
1677                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1678                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1679                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1680                         }
1681                 }
1682         }
1683         return NDR_ERR_SUCCESS;
1684 }
1685
1686 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1687 {
1688         uint32_t _ptr_servername;
1689         TALLOC_CTX *_mem_save_servername_0;
1690         uint32_t _ptr_printername;
1691         TALLOC_CTX *_mem_save_printername_0;
1692         uint32_t _ptr_sharename;
1693         TALLOC_CTX *_mem_save_sharename_0;
1694         uint32_t _ptr_portname;
1695         TALLOC_CTX *_mem_save_portname_0;
1696         uint32_t _ptr_drivername;
1697         TALLOC_CTX *_mem_save_drivername_0;
1698         uint32_t _ptr_comment;
1699         TALLOC_CTX *_mem_save_comment_0;
1700         uint32_t _ptr_location;
1701         TALLOC_CTX *_mem_save_location_0;
1702         uint32_t _ptr_devmode;
1703         TALLOC_CTX *_mem_save_devmode_0;
1704         uint32_t _ptr_sepfile;
1705         TALLOC_CTX *_mem_save_sepfile_0;
1706         uint32_t _ptr_printprocessor;
1707         TALLOC_CTX *_mem_save_printprocessor_0;
1708         uint32_t _ptr_datatype;
1709         TALLOC_CTX *_mem_save_datatype_0;
1710         uint32_t _ptr_parameters;
1711         TALLOC_CTX *_mem_save_parameters_0;
1712         uint32_t _ptr_secdesc;
1713         TALLOC_CTX *_mem_save_secdesc_0;
1714         if (ndr_flags & NDR_SCALARS) {
1715                 NDR_CHECK(ndr_pull_align(ndr, 5));
1716                 {
1717                         uint32_t _flags_save_string = ndr->flags;
1718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1720                         if (_ptr_servername) {
1721                                 NDR_PULL_ALLOC(ndr, r->servername);
1722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1723                         } else {
1724                                 r->servername = NULL;
1725                         }
1726                         ndr->flags = _flags_save_string;
1727                 }
1728                 {
1729                         uint32_t _flags_save_string = ndr->flags;
1730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1732                         if (_ptr_printername) {
1733                                 NDR_PULL_ALLOC(ndr, r->printername);
1734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1735                         } else {
1736                                 r->printername = NULL;
1737                         }
1738                         ndr->flags = _flags_save_string;
1739                 }
1740                 {
1741                         uint32_t _flags_save_string = ndr->flags;
1742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1744                         if (_ptr_sharename) {
1745                                 NDR_PULL_ALLOC(ndr, r->sharename);
1746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1747                         } else {
1748                                 r->sharename = NULL;
1749                         }
1750                         ndr->flags = _flags_save_string;
1751                 }
1752                 {
1753                         uint32_t _flags_save_string = ndr->flags;
1754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1756                         if (_ptr_portname) {
1757                                 NDR_PULL_ALLOC(ndr, r->portname);
1758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1759                         } else {
1760                                 r->portname = NULL;
1761                         }
1762                         ndr->flags = _flags_save_string;
1763                 }
1764                 {
1765                         uint32_t _flags_save_string = ndr->flags;
1766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1768                         if (_ptr_drivername) {
1769                                 NDR_PULL_ALLOC(ndr, r->drivername);
1770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1771                         } else {
1772                                 r->drivername = NULL;
1773                         }
1774                         ndr->flags = _flags_save_string;
1775                 }
1776                 {
1777                         uint32_t _flags_save_string = ndr->flags;
1778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1780                         if (_ptr_comment) {
1781                                 NDR_PULL_ALLOC(ndr, r->comment);
1782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1783                         } else {
1784                                 r->comment = NULL;
1785                         }
1786                         ndr->flags = _flags_save_string;
1787                 }
1788                 {
1789                         uint32_t _flags_save_string = ndr->flags;
1790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1792                         if (_ptr_location) {
1793                                 NDR_PULL_ALLOC(ndr, r->location);
1794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1795                         } else {
1796                                 r->location = NULL;
1797                         }
1798                         ndr->flags = _flags_save_string;
1799                 }
1800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1801                 if (_ptr_devmode) {
1802                         NDR_PULL_ALLOC(ndr, r->devmode);
1803                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1804                 } else {
1805                         r->devmode = NULL;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1811                         if (_ptr_sepfile) {
1812                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1814                         } else {
1815                                 r->sepfile = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 {
1820                         uint32_t _flags_save_string = ndr->flags;
1821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1823                         if (_ptr_printprocessor) {
1824                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1826                         } else {
1827                                 r->printprocessor = NULL;
1828                         }
1829                         ndr->flags = _flags_save_string;
1830                 }
1831                 {
1832                         uint32_t _flags_save_string = ndr->flags;
1833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1835                         if (_ptr_datatype) {
1836                                 NDR_PULL_ALLOC(ndr, r->datatype);
1837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1838                         } else {
1839                                 r->datatype = NULL;
1840                         }
1841                         ndr->flags = _flags_save_string;
1842                 }
1843                 {
1844                         uint32_t _flags_save_string = ndr->flags;
1845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1847                         if (_ptr_parameters) {
1848                                 NDR_PULL_ALLOC(ndr, r->parameters);
1849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1850                         } else {
1851                                 r->parameters = NULL;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1856                 if (_ptr_secdesc) {
1857                         NDR_PULL_ALLOC(ndr, r->secdesc);
1858                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1859                 } else {
1860                         r->secdesc = NULL;
1861                 }
1862                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1864                 if (r->priority > 99) {
1865                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1866                 }
1867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1870                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1873                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1874         }
1875         if (ndr_flags & NDR_BUFFERS) {
1876                 {
1877                         uint32_t _flags_save_string = ndr->flags;
1878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1879                         if (r->servername) {
1880                                 uint32_t _relative_save_offset;
1881                                 _relative_save_offset = ndr->offset;
1882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1883                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1884                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1887                                 if (ndr->offset > ndr->relative_highest_offset) {
1888                                         ndr->relative_highest_offset = ndr->offset;
1889                                 }
1890                                 ndr->offset = _relative_save_offset;
1891                         }
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         if (r->printername) {
1898                                 uint32_t _relative_save_offset;
1899                                 _relative_save_offset = ndr->offset;
1900                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1901                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1902                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1903                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1904                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1905                                 if (ndr->offset > ndr->relative_highest_offset) {
1906                                         ndr->relative_highest_offset = ndr->offset;
1907                                 }
1908                                 ndr->offset = _relative_save_offset;
1909                         }
1910                         ndr->flags = _flags_save_string;
1911                 }
1912                 {
1913                         uint32_t _flags_save_string = ndr->flags;
1914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1915                         if (r->sharename) {
1916                                 uint32_t _relative_save_offset;
1917                                 _relative_save_offset = ndr->offset;
1918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1919                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1920                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1923                                 if (ndr->offset > ndr->relative_highest_offset) {
1924                                         ndr->relative_highest_offset = ndr->offset;
1925                                 }
1926                                 ndr->offset = _relative_save_offset;
1927                         }
1928                         ndr->flags = _flags_save_string;
1929                 }
1930                 {
1931                         uint32_t _flags_save_string = ndr->flags;
1932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1933                         if (r->portname) {
1934                                 uint32_t _relative_save_offset;
1935                                 _relative_save_offset = ndr->offset;
1936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1937                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1938                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1941                                 if (ndr->offset > ndr->relative_highest_offset) {
1942                                         ndr->relative_highest_offset = ndr->offset;
1943                                 }
1944                                 ndr->offset = _relative_save_offset;
1945                         }
1946                         ndr->flags = _flags_save_string;
1947                 }
1948                 {
1949                         uint32_t _flags_save_string = ndr->flags;
1950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1951                         if (r->drivername) {
1952                                 uint32_t _relative_save_offset;
1953                                 _relative_save_offset = ndr->offset;
1954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1955                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1956                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1959                                 if (ndr->offset > ndr->relative_highest_offset) {
1960                                         ndr->relative_highest_offset = ndr->offset;
1961                                 }
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966                 {
1967                         uint32_t _flags_save_string = ndr->flags;
1968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1969                         if (r->comment) {
1970                                 uint32_t _relative_save_offset;
1971                                 _relative_save_offset = ndr->offset;
1972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1973                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1974                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1977                                 if (ndr->offset > ndr->relative_highest_offset) {
1978                                         ndr->relative_highest_offset = ndr->offset;
1979                                 }
1980                                 ndr->offset = _relative_save_offset;
1981                         }
1982                         ndr->flags = _flags_save_string;
1983                 }
1984                 {
1985                         uint32_t _flags_save_string = ndr->flags;
1986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1987                         if (r->location) {
1988                                 uint32_t _relative_save_offset;
1989                                 _relative_save_offset = ndr->offset;
1990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1991                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1992                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1995                                 if (ndr->offset > ndr->relative_highest_offset) {
1996                                         ndr->relative_highest_offset = ndr->offset;
1997                                 }
1998                                 ndr->offset = _relative_save_offset;
1999                         }
2000                         ndr->flags = _flags_save_string;
2001                 }
2002                 if (r->devmode) {
2003                         uint32_t _relative_save_offset;
2004                         _relative_save_offset = ndr->offset;
2005                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2006                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2007                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2008                         {
2009                                 struct ndr_pull *_ndr_devmode;
2010                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2011                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2012                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2013                         }
2014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2015                         if (ndr->offset > ndr->relative_highest_offset) {
2016                                 ndr->relative_highest_offset = ndr->offset;
2017                         }
2018                         ndr->offset = _relative_save_offset;
2019                 }
2020                 {
2021                         uint32_t _flags_save_string = ndr->flags;
2022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2023                         if (r->sepfile) {
2024                                 uint32_t _relative_save_offset;
2025                                 _relative_save_offset = ndr->offset;
2026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
2027                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
2028                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
2029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
2030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
2031                                 if (ndr->offset > ndr->relative_highest_offset) {
2032                                         ndr->relative_highest_offset = ndr->offset;
2033                                 }
2034                                 ndr->offset = _relative_save_offset;
2035                         }
2036                         ndr->flags = _flags_save_string;
2037                 }
2038                 {
2039                         uint32_t _flags_save_string = ndr->flags;
2040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2041                         if (r->printprocessor) {
2042                                 uint32_t _relative_save_offset;
2043                                 _relative_save_offset = ndr->offset;
2044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
2045                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
2046                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
2047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
2048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
2049                                 if (ndr->offset > ndr->relative_highest_offset) {
2050                                         ndr->relative_highest_offset = ndr->offset;
2051                                 }
2052                                 ndr->offset = _relative_save_offset;
2053                         }
2054                         ndr->flags = _flags_save_string;
2055                 }
2056                 {
2057                         uint32_t _flags_save_string = ndr->flags;
2058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2059                         if (r->datatype) {
2060                                 uint32_t _relative_save_offset;
2061                                 _relative_save_offset = ndr->offset;
2062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
2063                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
2064                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
2065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
2066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
2067                                 if (ndr->offset > ndr->relative_highest_offset) {
2068                                         ndr->relative_highest_offset = ndr->offset;
2069                                 }
2070                                 ndr->offset = _relative_save_offset;
2071                         }
2072                         ndr->flags = _flags_save_string;
2073                 }
2074                 {
2075                         uint32_t _flags_save_string = ndr->flags;
2076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2077                         if (r->parameters) {
2078                                 uint32_t _relative_save_offset;
2079                                 _relative_save_offset = ndr->offset;
2080                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
2081                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
2082                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
2083                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
2084                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
2085                                 if (ndr->offset > ndr->relative_highest_offset) {
2086                                         ndr->relative_highest_offset = ndr->offset;
2087                                 }
2088                                 ndr->offset = _relative_save_offset;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 if (r->secdesc) {
2093                         uint32_t _relative_save_offset;
2094                         _relative_save_offset = ndr->offset;
2095                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2096                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2097                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2098                         {
2099                                 struct ndr_pull *_ndr_secdesc;
2100                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2101                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2102                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2103                         }
2104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2105                         if (ndr->offset > ndr->relative_highest_offset) {
2106                                 ndr->relative_highest_offset = ndr->offset;
2107                         }
2108                         ndr->offset = _relative_save_offset;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "servername", r->servername);
2119         ndr->depth++;
2120         if (r->servername) {
2121                 ndr_print_string(ndr, "servername", r->servername);
2122         }
2123         ndr->depth--;
2124         ndr_print_ptr(ndr, "printername", r->printername);
2125         ndr->depth++;
2126         if (r->printername) {
2127                 ndr_print_string(ndr, "printername", r->printername);
2128         }
2129         ndr->depth--;
2130         ndr_print_ptr(ndr, "sharename", r->sharename);
2131         ndr->depth++;
2132         if (r->sharename) {
2133                 ndr_print_string(ndr, "sharename", r->sharename);
2134         }
2135         ndr->depth--;
2136         ndr_print_ptr(ndr, "portname", r->portname);
2137         ndr->depth++;
2138         if (r->portname) {
2139                 ndr_print_string(ndr, "portname", r->portname);
2140         }
2141         ndr->depth--;
2142         ndr_print_ptr(ndr, "drivername", r->drivername);
2143         ndr->depth++;
2144         if (r->drivername) {
2145                 ndr_print_string(ndr, "drivername", r->drivername);
2146         }
2147         ndr->depth--;
2148         ndr_print_ptr(ndr, "comment", r->comment);
2149         ndr->depth++;
2150         if (r->comment) {
2151                 ndr_print_string(ndr, "comment", r->comment);
2152         }
2153         ndr->depth--;
2154         ndr_print_ptr(ndr, "location", r->location);
2155         ndr->depth++;
2156         if (r->location) {
2157                 ndr_print_string(ndr, "location", r->location);
2158         }
2159         ndr->depth--;
2160         ndr_print_ptr(ndr, "devmode", r->devmode);
2161         ndr->depth++;
2162         if (r->devmode) {
2163                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2164         }
2165         ndr->depth--;
2166         ndr_print_ptr(ndr, "sepfile", r->sepfile);
2167         ndr->depth++;
2168         if (r->sepfile) {
2169                 ndr_print_string(ndr, "sepfile", r->sepfile);
2170         }
2171         ndr->depth--;
2172         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
2173         ndr->depth++;
2174         if (r->printprocessor) {
2175                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
2176         }
2177         ndr->depth--;
2178         ndr_print_ptr(ndr, "datatype", r->datatype);
2179         ndr->depth++;
2180         if (r->datatype) {
2181                 ndr_print_string(ndr, "datatype", r->datatype);
2182         }
2183         ndr->depth--;
2184         ndr_print_ptr(ndr, "parameters", r->parameters);
2185         ndr->depth++;
2186         if (r->parameters) {
2187                 ndr_print_string(ndr, "parameters", r->parameters);
2188         }
2189         ndr->depth--;
2190         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2191         ndr->depth++;
2192         if (r->secdesc) {
2193                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2194         }
2195         ndr->depth--;
2196         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2197         ndr_print_uint32(ndr, "priority", r->priority);
2198         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
2199         ndr_print_uint32(ndr, "starttime", r->starttime);
2200         ndr_print_uint32(ndr, "untiltime", r->untiltime);
2201         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2202         ndr_print_uint32(ndr, "cjobs", r->cjobs);
2203         ndr_print_uint32(ndr, "averageppm", r->averageppm);
2204         ndr->depth--;
2205 }
2206
2207 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
2208 {
2209         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
2210 }
2211
2212 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
2213 {
2214         if (ndr_flags & NDR_SCALARS) {
2215                 NDR_CHECK(ndr_push_align(ndr, 5));
2216                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2217                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2218         }
2219         if (ndr_flags & NDR_BUFFERS) {
2220                 if (r->secdesc) {
2221                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
2222                         {
2223                                 struct ndr_push *_ndr_secdesc;
2224                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2225                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2226                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2227                         }
2228                 }
2229         }
2230         return NDR_ERR_SUCCESS;
2231 }
2232
2233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
2234 {
2235         uint32_t _ptr_secdesc;
2236         TALLOC_CTX *_mem_save_secdesc_0;
2237         if (ndr_flags & NDR_SCALARS) {
2238                 NDR_CHECK(ndr_pull_align(ndr, 5));
2239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
2240                 if (_ptr_secdesc) {
2241                         NDR_PULL_ALLOC(ndr, r->secdesc);
2242                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
2243                 } else {
2244                         r->secdesc = NULL;
2245                 }
2246                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2247         }
2248         if (ndr_flags & NDR_BUFFERS) {
2249                 if (r->secdesc) {
2250                         uint32_t _relative_save_offset;
2251                         _relative_save_offset = ndr->offset;
2252                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
2253                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
2254                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
2255                         {
2256                                 struct ndr_pull *_ndr_secdesc;
2257                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
2258                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
2259                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
2260                         }
2261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
2262                         if (ndr->offset > ndr->relative_highest_offset) {
2263                                 ndr->relative_highest_offset = ndr->offset;
2264                         }
2265                         ndr->offset = _relative_save_offset;
2266                 }
2267         }
2268         return NDR_ERR_SUCCESS;
2269 }
2270
2271 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
2272 {
2273         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
2274         ndr->depth++;
2275         ndr_print_ptr(ndr, "secdesc", r->secdesc);
2276         ndr->depth++;
2277         if (r->secdesc) {
2278                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
2279         }
2280         ndr->depth--;
2281         ndr->depth--;
2282 }
2283
2284 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
2285 {
2286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
2287 }
2288
2289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
2290 {
2291         if (ndr_flags & NDR_SCALARS) {
2292                 NDR_CHECK(ndr_push_align(ndr, 5));
2293                 {
2294                         uint32_t _flags_save_string = ndr->flags;
2295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2297                         ndr->flags = _flags_save_string;
2298                 }
2299                 {
2300                         uint32_t _flags_save_string = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
2303                         ndr->flags = _flags_save_string;
2304                 }
2305                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2306                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2307         }
2308         if (ndr_flags & NDR_BUFFERS) {
2309                 {
2310                         uint32_t _flags_save_string = ndr->flags;
2311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2312                         if (r->printername) {
2313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2315                         }
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         if (r->servername) {
2322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
2323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
2324                         }
2325                         ndr->flags = _flags_save_string;
2326                 }
2327         }
2328         return NDR_ERR_SUCCESS;
2329 }
2330
2331 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
2332 {
2333         uint32_t _ptr_printername;
2334         TALLOC_CTX *_mem_save_printername_0;
2335         uint32_t _ptr_servername;
2336         TALLOC_CTX *_mem_save_servername_0;
2337         if (ndr_flags & NDR_SCALARS) {
2338                 NDR_CHECK(ndr_pull_align(ndr, 5));
2339                 {
2340                         uint32_t _flags_save_string = ndr->flags;
2341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2343                         if (_ptr_printername) {
2344                                 NDR_PULL_ALLOC(ndr, r->printername);
2345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2346                         } else {
2347                                 r->printername = NULL;
2348                         }
2349                         ndr->flags = _flags_save_string;
2350                 }
2351                 {
2352                         uint32_t _flags_save_string = ndr->flags;
2353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
2355                         if (_ptr_servername) {
2356                                 NDR_PULL_ALLOC(ndr, r->servername);
2357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
2358                         } else {
2359                                 r->servername = NULL;
2360                         }
2361                         ndr->flags = _flags_save_string;
2362                 }
2363                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2365         }
2366         if (ndr_flags & NDR_BUFFERS) {
2367                 {
2368                         uint32_t _flags_save_string = ndr->flags;
2369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2370                         if (r->printername) {
2371                                 uint32_t _relative_save_offset;
2372                                 _relative_save_offset = ndr->offset;
2373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2374                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2375                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2378                                 if (ndr->offset > ndr->relative_highest_offset) {
2379                                         ndr->relative_highest_offset = ndr->offset;
2380                                 }
2381                                 ndr->offset = _relative_save_offset;
2382                         }
2383                         ndr->flags = _flags_save_string;
2384                 }
2385                 {
2386                         uint32_t _flags_save_string = ndr->flags;
2387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2388                         if (r->servername) {
2389                                 uint32_t _relative_save_offset;
2390                                 _relative_save_offset = ndr->offset;
2391                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
2392                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2393                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
2394                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
2395                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
2396                                 if (ndr->offset > ndr->relative_highest_offset) {
2397                                         ndr->relative_highest_offset = ndr->offset;
2398                                 }
2399                                 ndr->offset = _relative_save_offset;
2400                         }
2401                         ndr->flags = _flags_save_string;
2402                 }
2403         }
2404         return NDR_ERR_SUCCESS;
2405 }
2406
2407 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
2408 {
2409         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
2410         ndr->depth++;
2411         ndr_print_ptr(ndr, "printername", r->printername);
2412         ndr->depth++;
2413         if (r->printername) {
2414                 ndr_print_string(ndr, "printername", r->printername);
2415         }
2416         ndr->depth--;
2417         ndr_print_ptr(ndr, "servername", r->servername);
2418         ndr->depth++;
2419         if (r->servername) {
2420                 ndr_print_string(ndr, "servername", r->servername);
2421         }
2422         ndr->depth--;
2423         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2424         ndr->depth--;
2425 }
2426
2427 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
2428 {
2429         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
2430 }
2431
2432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
2433 {
2434         if (ndr_flags & NDR_SCALARS) {
2435                 NDR_CHECK(ndr_push_align(ndr, 5));
2436                 {
2437                         uint32_t _flags_save_string = ndr->flags;
2438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
2440                         ndr->flags = _flags_save_string;
2441                 }
2442                 {
2443                         uint32_t _flags_save_string = ndr->flags;
2444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
2446                         ndr->flags = _flags_save_string;
2447                 }
2448                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
2449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
2450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
2451                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2452         }
2453         if (ndr_flags & NDR_BUFFERS) {
2454                 {
2455                         uint32_t _flags_save_string = ndr->flags;
2456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2457                         if (r->printername) {
2458                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
2459                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
2460                         }
2461                         ndr->flags = _flags_save_string;
2462                 }
2463                 {
2464                         uint32_t _flags_save_string = ndr->flags;
2465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2466                         if (r->portname) {
2467                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
2468                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
2469                         }
2470                         ndr->flags = _flags_save_string;
2471                 }
2472         }
2473         return NDR_ERR_SUCCESS;
2474 }
2475
2476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
2477 {
2478         uint32_t _ptr_printername;
2479         TALLOC_CTX *_mem_save_printername_0;
2480         uint32_t _ptr_portname;
2481         TALLOC_CTX *_mem_save_portname_0;
2482         if (ndr_flags & NDR_SCALARS) {
2483                 NDR_CHECK(ndr_pull_align(ndr, 5));
2484                 {
2485                         uint32_t _flags_save_string = ndr->flags;
2486                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2487                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
2488                         if (_ptr_printername) {
2489                                 NDR_PULL_ALLOC(ndr, r->printername);
2490                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
2491                         } else {
2492                                 r->printername = NULL;
2493                         }
2494                         ndr->flags = _flags_save_string;
2495                 }
2496                 {
2497                         uint32_t _flags_save_string = ndr->flags;
2498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2499                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
2500                         if (_ptr_portname) {
2501                                 NDR_PULL_ALLOC(ndr, r->portname);
2502                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
2503                         } else {
2504                                 r->portname = NULL;
2505                         }
2506                         ndr->flags = _flags_save_string;
2507                 }
2508                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
2509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
2510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
2511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2512         }
2513         if (ndr_flags & NDR_BUFFERS) {
2514                 {
2515                         uint32_t _flags_save_string = ndr->flags;
2516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2517                         if (r->printername) {
2518                                 uint32_t _relative_save_offset;
2519                                 _relative_save_offset = ndr->offset;
2520                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
2521                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
2522                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
2523                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
2524                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
2525                                 if (ndr->offset > ndr->relative_highest_offset) {
2526                                         ndr->relative_highest_offset = ndr->offset;
2527                                 }
2528                                 ndr->offset = _relative_save_offset;
2529                         }
2530                         ndr->flags = _flags_save_string;
2531                 }
2532                 {
2533                         uint32_t _flags_save_string = ndr->flags;
2534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2535                         if (r->portname) {
2536                                 uint32_t _relative_save_offset;
2537                                 _relative_save_offset = ndr->offset;
2538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
2539                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
2540                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
2541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
2542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
2543                                 if (ndr->offset > ndr->relative_highest_offset) {
2544                                         ndr->relative_highest_offset = ndr->offset;
2545                                 }
2546                                 ndr->offset = _relative_save_offset;
2547                         }
2548                         ndr->flags = _flags_save_string;
2549                 }
2550         }
2551         return NDR_ERR_SUCCESS;
2552 }
2553
2554 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
2555 {
2556         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2557         ndr->depth++;
2558         ndr_print_ptr(ndr, "printername", r->printername);
2559         ndr->depth++;
2560         if (r->printername) {
2561                 ndr_print_string(ndr, "printername", r->printername);
2562         }
2563         ndr->depth--;
2564         ndr_print_ptr(ndr, "portname", r->portname);
2565         ndr->depth++;
2566         if (r->portname) {
2567                 ndr_print_string(ndr, "portname", r->portname);
2568         }
2569         ndr->depth--;
2570         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2571         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2572         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2573         ndr->depth--;
2574 }
2575
2576 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2577 {
2578         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2579 }
2580
2581 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2582 {
2583         if (ndr_flags & NDR_SCALARS) {
2584                 NDR_CHECK(ndr_push_align(ndr, 4));
2585                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2586                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2587         }
2588         if (ndr_flags & NDR_BUFFERS) {
2589         }
2590         return NDR_ERR_SUCCESS;
2591 }
2592
2593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2594 {
2595         if (ndr_flags & NDR_SCALARS) {
2596                 NDR_CHECK(ndr_pull_align(ndr, 4));
2597                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2598                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2599         }
2600         if (ndr_flags & NDR_BUFFERS) {
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2606 {
2607         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2608         ndr->depth++;
2609         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2610         ndr->depth--;
2611 }
2612
2613 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2614 {
2615         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2616 }
2617
2618 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2619 {
2620         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2621         return NDR_ERR_SUCCESS;
2622 }
2623
2624 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2625 {
2626         uint32_t v;
2627         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2628         *r = v;
2629         return NDR_ERR_SUCCESS;
2630 }
2631
2632 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2633 {
2634         ndr_print_uint32(ndr, name, r);
2635         ndr->depth++;
2636         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2637         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2638         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2639         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2640         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2641         ndr->depth--;
2642 }
2643
2644 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2645 {
2646         if (ndr_flags & NDR_SCALARS) {
2647                 NDR_CHECK(ndr_push_align(ndr, 5));
2648                 {
2649                         uint32_t _flags_save_string = ndr->flags;
2650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2652                         ndr->flags = _flags_save_string;
2653                 }
2654                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2655                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2656         }
2657         if (ndr_flags & NDR_BUFFERS) {
2658                 {
2659                         uint32_t _flags_save_string = ndr->flags;
2660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2661                         if (r->guid) {
2662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2664                         }
2665                         ndr->flags = _flags_save_string;
2666                 }
2667         }
2668         return NDR_ERR_SUCCESS;
2669 }
2670
2671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2672 {
2673         uint32_t _ptr_guid;
2674         TALLOC_CTX *_mem_save_guid_0;
2675         if (ndr_flags & NDR_SCALARS) {
2676                 NDR_CHECK(ndr_pull_align(ndr, 5));
2677                 {
2678                         uint32_t _flags_save_string = ndr->flags;
2679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2680                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2681                         if (_ptr_guid) {
2682                                 NDR_PULL_ALLOC(ndr, r->guid);
2683                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2684                         } else {
2685                                 r->guid = NULL;
2686                         }
2687                         ndr->flags = _flags_save_string;
2688                 }
2689                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2691         }
2692         if (ndr_flags & NDR_BUFFERS) {
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         if (r->guid) {
2697                                 uint32_t _relative_save_offset;
2698                                 _relative_save_offset = ndr->offset;
2699                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2700                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2701                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2702                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2703                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2704                                 if (ndr->offset > ndr->relative_highest_offset) {
2705                                         ndr->relative_highest_offset = ndr->offset;
2706                                 }
2707                                 ndr->offset = _relative_save_offset;
2708                         }
2709                         ndr->flags = _flags_save_string;
2710                 }
2711         }
2712         return NDR_ERR_SUCCESS;
2713 }
2714
2715 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2716 {
2717         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2718         ndr->depth++;
2719         ndr_print_ptr(ndr, "guid", r->guid);
2720         ndr->depth++;
2721         if (r->guid) {
2722                 ndr_print_string(ndr, "guid", r->guid);
2723         }
2724         ndr->depth--;
2725         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2726         ndr->depth--;
2727 }
2728
2729 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2730 {
2731         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2732 }
2733
2734 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2735 {
2736         if (ndr_flags & NDR_SCALARS) {
2737                 NDR_CHECK(ndr_push_align(ndr, 5));
2738                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2739                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2740         }
2741         if (ndr_flags & NDR_BUFFERS) {
2742                 if (r->devmode) {
2743                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2744                         {
2745                                 struct ndr_push *_ndr_devmode;
2746                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2747                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2748                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2749                         }
2750                 }
2751         }
2752         return NDR_ERR_SUCCESS;
2753 }
2754
2755 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2756 {
2757         uint32_t _ptr_devmode;
2758         TALLOC_CTX *_mem_save_devmode_0;
2759         if (ndr_flags & NDR_SCALARS) {
2760                 NDR_CHECK(ndr_pull_align(ndr, 5));
2761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2762                 if (_ptr_devmode) {
2763                         NDR_PULL_ALLOC(ndr, r->devmode);
2764                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2765                 } else {
2766                         r->devmode = NULL;
2767                 }
2768                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2769         }
2770         if (ndr_flags & NDR_BUFFERS) {
2771                 if (r->devmode) {
2772                         uint32_t _relative_save_offset;
2773                         _relative_save_offset = ndr->offset;
2774                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2775                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2777                         {
2778                                 struct ndr_pull *_ndr_devmode;
2779                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2780                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2781                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2782                         }
2783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2784                         if (ndr->offset > ndr->relative_highest_offset) {
2785                                 ndr->relative_highest_offset = ndr->offset;
2786                         }
2787                         ndr->offset = _relative_save_offset;
2788                 }
2789         }
2790         return NDR_ERR_SUCCESS;
2791 }
2792
2793 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2794 {
2795         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2796         ndr->depth++;
2797         ndr_print_ptr(ndr, "devmode", r->devmode);
2798         ndr->depth++;
2799         if (r->devmode) {
2800                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2801         }
2802         ndr->depth--;
2803         ndr->depth--;
2804 }
2805
2806 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2807 {
2808         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2809         if (ndr_flags & NDR_SCALARS) {
2810                 int level = ndr_push_get_switch_value(ndr, r);
2811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
2812                 switch (level) {
2813                         case 0: {
2814                                 NDR_CHECK(ndr_push_align(ndr, 5));
2815                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2816                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2817                         break; }
2818
2819                         case 1: {
2820                                 NDR_CHECK(ndr_push_align(ndr, 5));
2821                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2822                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2823                         break; }
2824
2825                         case 2: {
2826                                 NDR_CHECK(ndr_push_align(ndr, 5));
2827                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2828                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2829                         break; }
2830
2831                         case 3: {
2832                                 NDR_CHECK(ndr_push_align(ndr, 5));
2833                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2834                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2835                         break; }
2836
2837                         case 4: {
2838                                 NDR_CHECK(ndr_push_align(ndr, 5));
2839                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2840                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2841                         break; }
2842
2843                         case 5: {
2844                                 NDR_CHECK(ndr_push_align(ndr, 5));
2845                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2846                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2847                         break; }
2848
2849                         case 6: {
2850                                 NDR_CHECK(ndr_push_align(ndr, 4));
2851                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2852                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2853                         break; }
2854
2855                         case 7: {
2856                                 NDR_CHECK(ndr_push_align(ndr, 5));
2857                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2858                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2859                         break; }
2860
2861                         case 8: {
2862                                 NDR_CHECK(ndr_push_align(ndr, 5));
2863                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2864                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2865                         break; }
2866
2867                         case 9: {
2868                                 NDR_CHECK(ndr_push_align(ndr, 5));
2869                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2870                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2871                         break; }
2872
2873                         default: {
2874                         break; }
2875
2876                 }
2877         }
2878         if (ndr_flags & NDR_BUFFERS) {
2879                 int level = ndr_push_get_switch_value(ndr, r);
2880                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2881                 switch (level) {
2882                         case 0:
2883                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2884                         break;
2885
2886                         case 1:
2887                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2888                         break;
2889
2890                         case 2:
2891                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2892                         break;
2893
2894                         case 3:
2895                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2896                         break;
2897
2898                         case 4:
2899                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2900                         break;
2901
2902                         case 5:
2903                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2904                         break;
2905
2906                         case 6:
2907                         break;
2908
2909                         case 7:
2910                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2911                         break;
2912
2913                         case 8:
2914                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2915                         break;
2916
2917                         case 9:
2918                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2919                         break;
2920
2921                         default:
2922                         break;
2923
2924                 }
2925         }
2926         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2927         return NDR_ERR_SUCCESS;
2928 }
2929
2930 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2931 {
2932         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2933         int level;
2934         level = ndr_pull_get_switch_value(ndr, r);
2935         if (ndr_flags & NDR_SCALARS) {
2936                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
2937                 switch (level) {
2938                         case 0: {
2939                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2940                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2941                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2942                         break; }
2943
2944                         case 1: {
2945                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2946                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2947                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2948                         break; }
2949
2950                         case 2: {
2951                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2953                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2954                         break; }
2955
2956                         case 3: {
2957                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2958                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2959                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2960                         break; }
2961
2962                         case 4: {
2963                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2964                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2965                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2966                         break; }
2967
2968                         case 5: {
2969                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2970                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2971                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2972                         break; }
2973
2974                         case 6: {
2975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2977                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2978                         break; }
2979
2980                         case 7: {
2981                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2982                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2983                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2984                         break; }
2985
2986                         case 8: {
2987                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2988                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2989                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2990                         break; }
2991
2992                         case 9: {
2993                                 NDR_CHECK(ndr_pull_align(ndr, 5));
2994                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2995                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2996                         break; }
2997
2998                         default: {
2999                         break; }
3000
3001                 }
3002         }
3003         if (ndr_flags & NDR_BUFFERS) {
3004                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
3005                 switch (level) {
3006                         case 0:
3007                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
3008                         break;
3009
3010                         case 1:
3011                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
3012                         break;
3013
3014                         case 2:
3015                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
3016                         break;
3017
3018                         case 3:
3019                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
3020                         break;
3021
3022                         case 4:
3023                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
3024                         break;
3025
3026                         case 5:
3027                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
3028                         break;
3029
3030                         case 6:
3031                         break;
3032
3033                         case 7:
3034                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
3035                         break;
3036
3037                         case 8:
3038                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
3039                         break;
3040
3041                         case 9:
3042                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
3043                         break;
3044
3045                         default:
3046                         break;
3047
3048                 }
3049         }
3050         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
3051         return NDR_ERR_SUCCESS;
3052 }
3053
3054 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
3055 {
3056         int level;
3057         level = ndr_print_get_switch_value(ndr, r);
3058         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
3059         switch (level) {
3060                 case 0:
3061                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
3062                 break;
3063
3064                 case 1:
3065                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
3066                 break;
3067
3068                 case 2:
3069                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
3070                 break;
3071
3072                 case 3:
3073                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
3074                 break;
3075
3076                 case 4:
3077                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
3078                 break;
3079
3080                 case 5:
3081                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
3082                 break;
3083
3084                 case 6:
3085                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
3086                 break;
3087
3088                 case 7:
3089                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
3090                 break;
3091
3092                 case 8:
3093                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
3094                 break;
3095
3096                 case 9:
3097                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
3098                 break;
3099
3100                 default:
3101                 break;
3102
3103         }
3104 }
3105
3106 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
3107 {
3108         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
3109 }
3110
3111 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
3112 {
3113         if (ndr_flags & NDR_SCALARS) {
3114                 NDR_CHECK(ndr_push_align(ndr, 5));
3115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
3117                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3118         }
3119         if (ndr_flags & NDR_BUFFERS) {
3120                 if (r->devmode) {
3121                         {
3122                                 struct ndr_push *_ndr_devmode;
3123                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3124                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3125                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
3126                         }
3127                 }
3128         }
3129         return NDR_ERR_SUCCESS;
3130 }
3131
3132 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
3133 {
3134         uint32_t _ptr_devmode;
3135         TALLOC_CTX *_mem_save_devmode_0;
3136         if (ndr_flags & NDR_SCALARS) {
3137                 NDR_CHECK(ndr_pull_align(ndr, 5));
3138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
3139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3140                 if (_ptr_devmode) {
3141                         NDR_PULL_ALLOC(ndr, r->devmode);
3142                 } else {
3143                         r->devmode = NULL;
3144                 }
3145                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3146         }
3147         if (ndr_flags & NDR_BUFFERS) {
3148                 if (r->devmode) {
3149                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3150                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3151                         {
3152                                 struct ndr_pull *_ndr_devmode;
3153                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
3154                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
3155                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
3156                         }
3157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3158                 }
3159         }
3160         return NDR_ERR_SUCCESS;
3161 }
3162
3163 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
3164 {
3165         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
3166         ndr->depth++;
3167         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
3168         ndr_print_ptr(ndr, "devmode", r->devmode);
3169         ndr->depth++;
3170         if (r->devmode) {
3171                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3172         }
3173         ndr->depth--;
3174         ndr->depth--;
3175 }
3176
3177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
3178 {
3179         if (ndr_flags & NDR_SCALARS) {
3180                 NDR_CHECK(ndr_push_align(ndr, 5));
3181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3182                 {
3183                         uint32_t _flags_save_string = ndr->flags;
3184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3185                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3186                         ndr->flags = _flags_save_string;
3187                 }
3188                 {
3189                         uint32_t _flags_save_string = ndr->flags;
3190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3191                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3192                         ndr->flags = _flags_save_string;
3193                 }
3194                 {
3195                         uint32_t _flags_save_string = ndr->flags;
3196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3198                         ndr->flags = _flags_save_string;
3199                 }
3200                 {
3201                         uint32_t _flags_save_string = ndr->flags;
3202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3204                         ndr->flags = _flags_save_string;
3205                 }
3206                 {
3207                         uint32_t _flags_save_string = ndr->flags;
3208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3210                         ndr->flags = _flags_save_string;
3211                 }
3212                 {
3213                         uint32_t _flags_save_string = ndr->flags;
3214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3216                         ndr->flags = _flags_save_string;
3217                 }
3218                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3223                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3224                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3225         }
3226         if (ndr_flags & NDR_BUFFERS) {
3227                 {
3228                         uint32_t _flags_save_string = ndr->flags;
3229                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3230                         if (r->printer_name) {
3231                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3232                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3233                         }
3234                         ndr->flags = _flags_save_string;
3235                 }
3236                 {
3237                         uint32_t _flags_save_string = ndr->flags;
3238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3239                         if (r->server_name) {
3240                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3241                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3242                         }
3243                         ndr->flags = _flags_save_string;
3244                 }
3245                 {
3246                         uint32_t _flags_save_string = ndr->flags;
3247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3248                         if (r->user_name) {
3249                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3250                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3251                         }
3252                         ndr->flags = _flags_save_string;
3253                 }
3254                 {
3255                         uint32_t _flags_save_string = ndr->flags;
3256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3257                         if (r->document_name) {
3258                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3259                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3260                         }
3261                         ndr->flags = _flags_save_string;
3262                 }
3263                 {
3264                         uint32_t _flags_save_string = ndr->flags;
3265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3266                         if (r->data_type) {
3267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3269                         }
3270                         ndr->flags = _flags_save_string;
3271                 }
3272                 {
3273                         uint32_t _flags_save_string = ndr->flags;
3274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3275                         if (r->text_status) {
3276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281         }
3282         return NDR_ERR_SUCCESS;
3283 }
3284
3285 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
3286 {
3287         uint32_t _ptr_printer_name;
3288         TALLOC_CTX *_mem_save_printer_name_0;
3289         uint32_t _ptr_server_name;
3290         TALLOC_CTX *_mem_save_server_name_0;
3291         uint32_t _ptr_user_name;
3292         TALLOC_CTX *_mem_save_user_name_0;
3293         uint32_t _ptr_document_name;
3294         TALLOC_CTX *_mem_save_document_name_0;
3295         uint32_t _ptr_data_type;
3296         TALLOC_CTX *_mem_save_data_type_0;
3297         uint32_t _ptr_text_status;
3298         TALLOC_CTX *_mem_save_text_status_0;
3299         if (ndr_flags & NDR_SCALARS) {
3300                 NDR_CHECK(ndr_pull_align(ndr, 5));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3302                 {
3303                         uint32_t _flags_save_string = ndr->flags;
3304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3306                         if (_ptr_printer_name) {
3307                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3309                         } else {
3310                                 r->printer_name = NULL;
3311                         }
3312                         ndr->flags = _flags_save_string;
3313                 }
3314                 {
3315                         uint32_t _flags_save_string = ndr->flags;
3316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3318                         if (_ptr_server_name) {
3319                                 NDR_PULL_ALLOC(ndr, r->server_name);
3320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3321                         } else {
3322                                 r->server_name = NULL;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3330                         if (_ptr_user_name) {
3331                                 NDR_PULL_ALLOC(ndr, r->user_name);
3332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3333                         } else {
3334                                 r->user_name = NULL;
3335                         }
3336                         ndr->flags = _flags_save_string;
3337                 }
3338                 {
3339                         uint32_t _flags_save_string = ndr->flags;
3340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3342                         if (_ptr_document_name) {
3343                                 NDR_PULL_ALLOC(ndr, r->document_name);
3344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3345                         } else {
3346                                 r->document_name = NULL;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3354                         if (_ptr_data_type) {
3355                                 NDR_PULL_ALLOC(ndr, r->data_type);
3356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3357                         } else {
3358                                 r->data_type = NULL;
3359                         }
3360                         ndr->flags = _flags_save_string;
3361                 }
3362                 {
3363                         uint32_t _flags_save_string = ndr->flags;
3364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3366                         if (_ptr_text_status) {
3367                                 NDR_PULL_ALLOC(ndr, r->text_status);
3368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3369                         } else {
3370                                 r->text_status = NULL;
3371                         }
3372                         ndr->flags = _flags_save_string;
3373                 }
3374                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3376                 if (r->priority > 99) {
3377                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3378                 }
3379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3382                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->printer_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3393                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3397                                 if (ndr->offset > ndr->relative_highest_offset) {
3398                                         ndr->relative_highest_offset = ndr->offset;
3399                                 }
3400                                 ndr->offset = _relative_save_offset;
3401                         }
3402                         ndr->flags = _flags_save_string;
3403                 }
3404                 {
3405                         uint32_t _flags_save_string = ndr->flags;
3406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3407                         if (r->server_name) {
3408                                 uint32_t _relative_save_offset;
3409                                 _relative_save_offset = ndr->offset;
3410                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3411                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3412                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3413                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3414                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3415                                 if (ndr->offset > ndr->relative_highest_offset) {
3416                                         ndr->relative_highest_offset = ndr->offset;
3417                                 }
3418                                 ndr->offset = _relative_save_offset;
3419                         }
3420                         ndr->flags = _flags_save_string;
3421                 }
3422                 {
3423                         uint32_t _flags_save_string = ndr->flags;
3424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3425                         if (r->user_name) {
3426                                 uint32_t _relative_save_offset;
3427                                 _relative_save_offset = ndr->offset;
3428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3429                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3430                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3433                                 if (ndr->offset > ndr->relative_highest_offset) {
3434                                         ndr->relative_highest_offset = ndr->offset;
3435                                 }
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->document_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3447                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3451                                 if (ndr->offset > ndr->relative_highest_offset) {
3452                                         ndr->relative_highest_offset = ndr->offset;
3453                                 }
3454                                 ndr->offset = _relative_save_offset;
3455                         }
3456                         ndr->flags = _flags_save_string;
3457                 }
3458                 {
3459                         uint32_t _flags_save_string = ndr->flags;
3460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3461                         if (r->data_type) {
3462                                 uint32_t _relative_save_offset;
3463                                 _relative_save_offset = ndr->offset;
3464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3465                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3469                                 if (ndr->offset > ndr->relative_highest_offset) {
3470                                         ndr->relative_highest_offset = ndr->offset;
3471                                 }
3472                                 ndr->offset = _relative_save_offset;
3473                         }
3474                         ndr->flags = _flags_save_string;
3475                 }
3476                 {
3477                         uint32_t _flags_save_string = ndr->flags;
3478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3479                         if (r->text_status) {
3480                                 uint32_t _relative_save_offset;
3481                                 _relative_save_offset = ndr->offset;
3482                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3483                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3484                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3485                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3486                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3487                                 if (ndr->offset > ndr->relative_highest_offset) {
3488                                         ndr->relative_highest_offset = ndr->offset;
3489                                 }
3490                                 ndr->offset = _relative_save_offset;
3491                         }
3492                         ndr->flags = _flags_save_string;
3493                 }
3494         }
3495         return NDR_ERR_SUCCESS;
3496 }
3497
3498 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
3499 {
3500         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
3501         ndr->depth++;
3502         ndr_print_uint32(ndr, "job_id", r->job_id);
3503         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3504         ndr->depth++;
3505         if (r->printer_name) {
3506                 ndr_print_string(ndr, "printer_name", r->printer_name);
3507         }
3508         ndr->depth--;
3509         ndr_print_ptr(ndr, "server_name", r->server_name);
3510         ndr->depth++;
3511         if (r->server_name) {
3512                 ndr_print_string(ndr, "server_name", r->server_name);
3513         }
3514         ndr->depth--;
3515         ndr_print_ptr(ndr, "user_name", r->user_name);
3516         ndr->depth++;
3517         if (r->user_name) {
3518                 ndr_print_string(ndr, "user_name", r->user_name);
3519         }
3520         ndr->depth--;
3521         ndr_print_ptr(ndr, "document_name", r->document_name);
3522         ndr->depth++;
3523         if (r->document_name) {
3524                 ndr_print_string(ndr, "document_name", r->document_name);
3525         }
3526         ndr->depth--;
3527         ndr_print_ptr(ndr, "data_type", r->data_type);
3528         ndr->depth++;
3529         if (r->data_type) {
3530                 ndr_print_string(ndr, "data_type", r->data_type);
3531         }
3532         ndr->depth--;
3533         ndr_print_ptr(ndr, "text_status", r->text_status);
3534         ndr->depth++;
3535         if (r->text_status) {
3536                 ndr_print_string(ndr, "text_status", r->text_status);
3537         }
3538         ndr->depth--;
3539         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3540         ndr_print_uint32(ndr, "priority", r->priority);
3541         ndr_print_uint32(ndr, "position", r->position);
3542         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3543         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3544         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3545         ndr->depth--;
3546 }
3547
3548 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
3549 {
3550         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
3551 }
3552
3553 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
3554 {
3555         if (ndr_flags & NDR_SCALARS) {
3556                 NDR_CHECK(ndr_push_align(ndr, 5));
3557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3558                 {
3559                         uint32_t _flags_save_string = ndr->flags;
3560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3562                         ndr->flags = _flags_save_string;
3563                 }
3564                 {
3565                         uint32_t _flags_save_string = ndr->flags;
3566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3568                         ndr->flags = _flags_save_string;
3569                 }
3570                 {
3571                         uint32_t _flags_save_string = ndr->flags;
3572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3574                         ndr->flags = _flags_save_string;
3575                 }
3576                 {
3577                         uint32_t _flags_save_string = ndr->flags;
3578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3580                         ndr->flags = _flags_save_string;
3581                 }
3582                 {
3583                         uint32_t _flags_save_string = ndr->flags;
3584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3586                         ndr->flags = _flags_save_string;
3587                 }
3588                 {
3589                         uint32_t _flags_save_string = ndr->flags;
3590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3591                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3592                         ndr->flags = _flags_save_string;
3593                 }
3594                 {
3595                         uint32_t _flags_save_string = ndr->flags;
3596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3597                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3598                         ndr->flags = _flags_save_string;
3599                 }
3600                 {
3601                         uint32_t _flags_save_string = ndr->flags;
3602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3603                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3604                         ndr->flags = _flags_save_string;
3605                 }
3606                 {
3607                         uint32_t _flags_save_string = ndr->flags;
3608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3613                 {
3614                         uint32_t _flags_save_string = ndr->flags;
3615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3617                         ndr->flags = _flags_save_string;
3618                 }
3619                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3620                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3627                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3631         }
3632         if (ndr_flags & NDR_BUFFERS) {
3633                 {
3634                         uint32_t _flags_save_string = ndr->flags;
3635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3636                         if (r->printer_name) {
3637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3639                         }
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         if (r->server_name) {
3646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3648                         }
3649                         ndr->flags = _flags_save_string;
3650                 }
3651                 {
3652                         uint32_t _flags_save_string = ndr->flags;
3653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3654                         if (r->user_name) {
3655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3657                         }
3658                         ndr->flags = _flags_save_string;
3659                 }
3660                 {
3661                         uint32_t _flags_save_string = ndr->flags;
3662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3663                         if (r->document_name) {
3664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3666                         }
3667                         ndr->flags = _flags_save_string;
3668                 }
3669                 {
3670                         uint32_t _flags_save_string = ndr->flags;
3671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3672                         if (r->notify_name) {
3673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3675                         }
3676                         ndr->flags = _flags_save_string;
3677                 }
3678                 {
3679                         uint32_t _flags_save_string = ndr->flags;
3680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3681                         if (r->data_type) {
3682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3684                         }
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 {
3688                         uint32_t _flags_save_string = ndr->flags;
3689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3690                         if (r->print_processor) {
3691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3693                         }
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 {
3697                         uint32_t _flags_save_string = ndr->flags;
3698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3699                         if (r->parameters) {
3700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3702                         }
3703                         ndr->flags = _flags_save_string;
3704                 }
3705                 {
3706                         uint32_t _flags_save_string = ndr->flags;
3707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3708                         if (r->driver_name) {
3709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3711                         }
3712                         ndr->flags = _flags_save_string;
3713                 }
3714                 if (r->devmode) {
3715                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3716                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3717                 }
3718                 {
3719                         uint32_t _flags_save_string = ndr->flags;
3720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3721                         if (r->text_status) {
3722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3724                         }
3725                         ndr->flags = _flags_save_string;
3726                 }
3727                 if (r->secdesc) {
3728                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3729                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3730                 }
3731         }
3732         return NDR_ERR_SUCCESS;
3733 }
3734
3735 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3736 {
3737         uint32_t _ptr_printer_name;
3738         TALLOC_CTX *_mem_save_printer_name_0;
3739         uint32_t _ptr_server_name;
3740         TALLOC_CTX *_mem_save_server_name_0;
3741         uint32_t _ptr_user_name;
3742         TALLOC_CTX *_mem_save_user_name_0;
3743         uint32_t _ptr_document_name;
3744         TALLOC_CTX *_mem_save_document_name_0;
3745         uint32_t _ptr_notify_name;
3746         TALLOC_CTX *_mem_save_notify_name_0;
3747         uint32_t _ptr_data_type;
3748         TALLOC_CTX *_mem_save_data_type_0;
3749         uint32_t _ptr_print_processor;
3750         TALLOC_CTX *_mem_save_print_processor_0;
3751         uint32_t _ptr_parameters;
3752         TALLOC_CTX *_mem_save_parameters_0;
3753         uint32_t _ptr_driver_name;
3754         TALLOC_CTX *_mem_save_driver_name_0;
3755         uint32_t _ptr_devmode;
3756         TALLOC_CTX *_mem_save_devmode_0;
3757         uint32_t _ptr_text_status;
3758         TALLOC_CTX *_mem_save_text_status_0;
3759         uint32_t _ptr_secdesc;
3760         TALLOC_CTX *_mem_save_secdesc_0;
3761         if (ndr_flags & NDR_SCALARS) {
3762                 NDR_CHECK(ndr_pull_align(ndr, 5));
3763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3768                         if (_ptr_printer_name) {
3769                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3771                         } else {
3772                                 r->printer_name = NULL;
3773                         }
3774                         ndr->flags = _flags_save_string;
3775                 }
3776                 {
3777                         uint32_t _flags_save_string = ndr->flags;
3778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3780                         if (_ptr_server_name) {
3781                                 NDR_PULL_ALLOC(ndr, r->server_name);
3782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3783                         } else {
3784                                 r->server_name = NULL;
3785                         }
3786                         ndr->flags = _flags_save_string;
3787                 }
3788                 {
3789                         uint32_t _flags_save_string = ndr->flags;
3790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3792                         if (_ptr_user_name) {
3793                                 NDR_PULL_ALLOC(ndr, r->user_name);
3794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3795                         } else {
3796                                 r->user_name = NULL;
3797                         }
3798                         ndr->flags = _flags_save_string;
3799                 }
3800                 {
3801                         uint32_t _flags_save_string = ndr->flags;
3802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3804                         if (_ptr_document_name) {
3805                                 NDR_PULL_ALLOC(ndr, r->document_name);
3806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3807                         } else {
3808                                 r->document_name = NULL;
3809                         }
3810                         ndr->flags = _flags_save_string;
3811                 }
3812                 {
3813                         uint32_t _flags_save_string = ndr->flags;
3814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3816                         if (_ptr_notify_name) {
3817                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3819                         } else {
3820                                 r->notify_name = NULL;
3821                         }
3822                         ndr->flags = _flags_save_string;
3823                 }
3824                 {
3825                         uint32_t _flags_save_string = ndr->flags;
3826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3828                         if (_ptr_data_type) {
3829                                 NDR_PULL_ALLOC(ndr, r->data_type);
3830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3831                         } else {
3832                                 r->data_type = NULL;
3833                         }
3834                         ndr->flags = _flags_save_string;
3835                 }
3836                 {
3837                         uint32_t _flags_save_string = ndr->flags;
3838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3839                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3840                         if (_ptr_print_processor) {
3841                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3842                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3843                         } else {
3844                                 r->print_processor = NULL;
3845                         }
3846                         ndr->flags = _flags_save_string;
3847                 }
3848                 {
3849                         uint32_t _flags_save_string = ndr->flags;
3850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3852                         if (_ptr_parameters) {
3853                                 NDR_PULL_ALLOC(ndr, r->parameters);
3854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3855                         } else {
3856                                 r->parameters = NULL;
3857                         }
3858                         ndr->flags = _flags_save_string;
3859                 }
3860                 {
3861                         uint32_t _flags_save_string = ndr->flags;
3862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3863                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3864                         if (_ptr_driver_name) {
3865                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3866                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3867                         } else {
3868                                 r->driver_name = NULL;
3869                         }
3870                         ndr->flags = _flags_save_string;
3871                 }
3872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3873                 if (_ptr_devmode) {
3874                         NDR_PULL_ALLOC(ndr, r->devmode);
3875                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3876                 } else {
3877                         r->devmode = NULL;
3878                 }
3879                 {
3880                         uint32_t _flags_save_string = ndr->flags;
3881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3883                         if (_ptr_text_status) {
3884                                 NDR_PULL_ALLOC(ndr, r->text_status);
3885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3886                         } else {
3887                                 r->text_status = NULL;
3888                         }
3889                         ndr->flags = _flags_save_string;
3890                 }
3891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3892                 if (_ptr_secdesc) {
3893                         NDR_PULL_ALLOC(ndr, r->secdesc);
3894                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3895                 } else {
3896                         r->secdesc = NULL;
3897                 }
3898                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3900                 if (r->priority > 99) {
3901                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3902                 }
3903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3908                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3912         }
3913         if (ndr_flags & NDR_BUFFERS) {
3914                 {
3915                         uint32_t _flags_save_string = ndr->flags;
3916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3917                         if (r->printer_name) {
3918                                 uint32_t _relative_save_offset;
3919                                 _relative_save_offset = ndr->offset;
3920                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3921                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3922                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3923                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3924                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3925                                 if (ndr->offset > ndr->relative_highest_offset) {
3926                                         ndr->relative_highest_offset = ndr->offset;
3927                                 }
3928                                 ndr->offset = _relative_save_offset;
3929                         }
3930                         ndr->flags = _flags_save_string;
3931                 }
3932                 {
3933                         uint32_t _flags_save_string = ndr->flags;
3934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3935                         if (r->server_name) {
3936                                 uint32_t _relative_save_offset;
3937                                 _relative_save_offset = ndr->offset;
3938                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3939                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3940                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3941                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3942                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3943                                 if (ndr->offset > ndr->relative_highest_offset) {
3944                                         ndr->relative_highest_offset = ndr->offset;
3945                                 }
3946                                 ndr->offset = _relative_save_offset;
3947                         }
3948                         ndr->flags = _flags_save_string;
3949                 }
3950                 {
3951                         uint32_t _flags_save_string = ndr->flags;
3952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3953                         if (r->user_name) {
3954                                 uint32_t _relative_save_offset;
3955                                 _relative_save_offset = ndr->offset;
3956                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3957                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3958                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3959                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3960                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3961                                 if (ndr->offset > ndr->relative_highest_offset) {
3962                                         ndr->relative_highest_offset = ndr->offset;
3963                                 }
3964                                 ndr->offset = _relative_save_offset;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 {
3969                         uint32_t _flags_save_string = ndr->flags;
3970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3971                         if (r->document_name) {
3972                                 uint32_t _relative_save_offset;
3973                                 _relative_save_offset = ndr->offset;
3974                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3975                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3976                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3977                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3978                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3979                                 if (ndr->offset > ndr->relative_highest_offset) {
3980                                         ndr->relative_highest_offset = ndr->offset;
3981                                 }
3982                                 ndr->offset = _relative_save_offset;
3983                         }
3984                         ndr->flags = _flags_save_string;
3985                 }
3986                 {
3987                         uint32_t _flags_save_string = ndr->flags;
3988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3989                         if (r->notify_name) {
3990                                 uint32_t _relative_save_offset;
3991                                 _relative_save_offset = ndr->offset;
3992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3993                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3994                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3997                                 if (ndr->offset > ndr->relative_highest_offset) {
3998                                         ndr->relative_highest_offset = ndr->offset;
3999                                 }
4000                                 ndr->offset = _relative_save_offset;
4001                         }
4002                         ndr->flags = _flags_save_string;
4003                 }
4004                 {
4005                         uint32_t _flags_save_string = ndr->flags;
4006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4007                         if (r->data_type) {
4008                                 uint32_t _relative_save_offset;
4009                                 _relative_save_offset = ndr->offset;
4010                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4011                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4012                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4013                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4014                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4015                                 if (ndr->offset > ndr->relative_highest_offset) {
4016                                         ndr->relative_highest_offset = ndr->offset;
4017                                 }
4018                                 ndr->offset = _relative_save_offset;
4019                         }
4020                         ndr->flags = _flags_save_string;
4021                 }
4022                 {
4023                         uint32_t _flags_save_string = ndr->flags;
4024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4025                         if (r->print_processor) {
4026                                 uint32_t _relative_save_offset;
4027                                 _relative_save_offset = ndr->offset;
4028                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4029                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4031                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4032                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4033                                 if (ndr->offset > ndr->relative_highest_offset) {
4034                                         ndr->relative_highest_offset = ndr->offset;
4035                                 }
4036                                 ndr->offset = _relative_save_offset;
4037                         }
4038                         ndr->flags = _flags_save_string;
4039                 }
4040                 {
4041                         uint32_t _flags_save_string = ndr->flags;
4042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4043                         if (r->parameters) {
4044                                 uint32_t _relative_save_offset;
4045                                 _relative_save_offset = ndr->offset;
4046                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4047                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4048                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4049                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4050                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4051                                 if (ndr->offset > ndr->relative_highest_offset) {
4052                                         ndr->relative_highest_offset = ndr->offset;
4053                                 }
4054                                 ndr->offset = _relative_save_offset;
4055                         }
4056                         ndr->flags = _flags_save_string;
4057                 }
4058                 {
4059                         uint32_t _flags_save_string = ndr->flags;
4060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4061                         if (r->driver_name) {
4062                                 uint32_t _relative_save_offset;
4063                                 _relative_save_offset = ndr->offset;
4064                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4065                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4066                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4067                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4068                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4069                                 if (ndr->offset > ndr->relative_highest_offset) {
4070                                         ndr->relative_highest_offset = ndr->offset;
4071                                 }
4072                                 ndr->offset = _relative_save_offset;
4073                         }
4074                         ndr->flags = _flags_save_string;
4075                 }
4076                 if (r->devmode) {
4077                         uint32_t _relative_save_offset;
4078                         _relative_save_offset = ndr->offset;
4079                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4080                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4081                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4082                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4084                         if (ndr->offset > ndr->relative_highest_offset) {
4085                                 ndr->relative_highest_offset = ndr->offset;
4086                         }
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089                 {
4090                         uint32_t _flags_save_string = ndr->flags;
4091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4092                         if (r->text_status) {
4093                                 uint32_t _relative_save_offset;
4094                                 _relative_save_offset = ndr->offset;
4095                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4096                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4097                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4098                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4099                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4100                                 if (ndr->offset > ndr->relative_highest_offset) {
4101                                         ndr->relative_highest_offset = ndr->offset;
4102                                 }
4103                                 ndr->offset = _relative_save_offset;
4104                         }
4105                         ndr->flags = _flags_save_string;
4106                 }
4107                 if (r->secdesc) {
4108                         uint32_t _relative_save_offset;
4109                         _relative_save_offset = ndr->offset;
4110                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4111                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4112                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4113                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4115                         if (ndr->offset > ndr->relative_highest_offset) {
4116                                 ndr->relative_highest_offset = ndr->offset;
4117                         }
4118                         ndr->offset = _relative_save_offset;
4119                 }
4120         }
4121         return NDR_ERR_SUCCESS;
4122 }
4123
4124 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
4125 {
4126         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
4127         ndr->depth++;
4128         ndr_print_uint32(ndr, "job_id", r->job_id);
4129         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4130         ndr->depth++;
4131         if (r->printer_name) {
4132                 ndr_print_string(ndr, "printer_name", r->printer_name);
4133         }
4134         ndr->depth--;
4135         ndr_print_ptr(ndr, "server_name", r->server_name);
4136         ndr->depth++;
4137         if (r->server_name) {
4138                 ndr_print_string(ndr, "server_name", r->server_name);
4139         }
4140         ndr->depth--;
4141         ndr_print_ptr(ndr, "user_name", r->user_name);
4142         ndr->depth++;
4143         if (r->user_name) {
4144                 ndr_print_string(ndr, "user_name", r->user_name);
4145         }
4146         ndr->depth--;
4147         ndr_print_ptr(ndr, "document_name", r->document_name);
4148         ndr->depth++;
4149         if (r->document_name) {
4150                 ndr_print_string(ndr, "document_name", r->document_name);
4151         }
4152         ndr->depth--;
4153         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4154         ndr->depth++;
4155         if (r->notify_name) {
4156                 ndr_print_string(ndr, "notify_name", r->notify_name);
4157         }
4158         ndr->depth--;
4159         ndr_print_ptr(ndr, "data_type", r->data_type);
4160         ndr->depth++;
4161         if (r->data_type) {
4162                 ndr_print_string(ndr, "data_type", r->data_type);
4163         }
4164         ndr->depth--;
4165         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4166         ndr->depth++;
4167         if (r->print_processor) {
4168                 ndr_print_string(ndr, "print_processor", r->print_processor);
4169         }
4170         ndr->depth--;
4171         ndr_print_ptr(ndr, "parameters", r->parameters);
4172         ndr->depth++;
4173         if (r->parameters) {
4174                 ndr_print_string(ndr, "parameters", r->parameters);
4175         }
4176         ndr->depth--;
4177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4178         ndr->depth++;
4179         if (r->driver_name) {
4180                 ndr_print_string(ndr, "driver_name", r->driver_name);
4181         }
4182         ndr->depth--;
4183         ndr_print_ptr(ndr, "devmode", r->devmode);
4184         ndr->depth++;
4185         if (r->devmode) {
4186                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4187         }
4188         ndr->depth--;
4189         ndr_print_ptr(ndr, "text_status", r->text_status);
4190         ndr->depth++;
4191         if (r->text_status) {
4192                 ndr_print_string(ndr, "text_status", r->text_status);
4193         }
4194         ndr->depth--;
4195         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4196         ndr->depth++;
4197         if (r->secdesc) {
4198                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4199         }
4200         ndr->depth--;
4201         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4202         ndr_print_uint32(ndr, "priority", r->priority);
4203         ndr_print_uint32(ndr, "position", r->position);
4204         ndr_print_uint32(ndr, "start_time", r->start_time);
4205         ndr_print_uint32(ndr, "until_time", r->until_time);
4206         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4207         ndr_print_uint32(ndr, "size", r->size);
4208         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4209         ndr_print_uint32(ndr, "time", r->time);
4210         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4211         ndr->depth--;
4212 }
4213
4214 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
4215 {
4216         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
4217 }
4218
4219 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
4220 {
4221         if (ndr_flags & NDR_SCALARS) {
4222                 NDR_CHECK(ndr_push_align(ndr, 4));
4223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
4225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
4226                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
4227         }
4228         if (ndr_flags & NDR_BUFFERS) {
4229         }
4230         return NDR_ERR_SUCCESS;
4231 }
4232
4233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
4234 {
4235         if (ndr_flags & NDR_SCALARS) {
4236                 NDR_CHECK(ndr_pull_align(ndr, 4));
4237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
4239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
4240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
4241         }
4242         if (ndr_flags & NDR_BUFFERS) {
4243         }
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
4248 {
4249         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
4250         ndr->depth++;
4251         ndr_print_uint32(ndr, "job_id", r->job_id);
4252         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
4253         ndr_print_uint32(ndr, "reserved", r->reserved);
4254         ndr->depth--;
4255 }
4256
4257 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
4258 {
4259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
4260 }
4261
4262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
4263 {
4264         if (ndr_flags & NDR_SCALARS) {
4265                 NDR_CHECK(ndr_push_align(ndr, 5));
4266                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4267                 {
4268                         uint32_t _flags_save_string = ndr->flags;
4269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4270                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 {
4274                         uint32_t _flags_save_string = ndr->flags;
4275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4276                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
4277                         ndr->flags = _flags_save_string;
4278                 }
4279                 {
4280                         uint32_t _flags_save_string = ndr->flags;
4281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4282                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
4283                         ndr->flags = _flags_save_string;
4284                 }
4285                 {
4286                         uint32_t _flags_save_string = ndr->flags;
4287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
4289                         ndr->flags = _flags_save_string;
4290                 }
4291                 {
4292                         uint32_t _flags_save_string = ndr->flags;
4293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
4295                         ndr->flags = _flags_save_string;
4296                 }
4297                 {
4298                         uint32_t _flags_save_string = ndr->flags;
4299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
4301                         ndr->flags = _flags_save_string;
4302                 }
4303                 {
4304                         uint32_t _flags_save_string = ndr->flags;
4305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
4307                         ndr->flags = _flags_save_string;
4308                 }
4309                 {
4310                         uint32_t _flags_save_string = ndr->flags;
4311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
4313                         ndr->flags = _flags_save_string;
4314                 }
4315                 {
4316                         uint32_t _flags_save_string = ndr->flags;
4317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4319                         ndr->flags = _flags_save_string;
4320                 }
4321                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
4322                 {
4323                         uint32_t _flags_save_string = ndr->flags;
4324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4325                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
4326                         ndr->flags = _flags_save_string;
4327                 }
4328                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
4329                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4336                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
4340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4341         }
4342         if (ndr_flags & NDR_BUFFERS) {
4343                 {
4344                         uint32_t _flags_save_string = ndr->flags;
4345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4346                         if (r->printer_name) {
4347                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
4348                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
4349                         }
4350                         ndr->flags = _flags_save_string;
4351                 }
4352                 {
4353                         uint32_t _flags_save_string = ndr->flags;
4354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4355                         if (r->server_name) {
4356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
4357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
4358                         }
4359                         ndr->flags = _flags_save_string;
4360                 }
4361                 {
4362                         uint32_t _flags_save_string = ndr->flags;
4363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4364                         if (r->user_name) {
4365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
4366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
4367                         }
4368                         ndr->flags = _flags_save_string;
4369                 }
4370                 {
4371                         uint32_t _flags_save_string = ndr->flags;
4372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4373                         if (r->document_name) {
4374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
4375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
4376                         }
4377                         ndr->flags = _flags_save_string;
4378                 }
4379                 {
4380                         uint32_t _flags_save_string = ndr->flags;
4381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4382                         if (r->notify_name) {
4383                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
4384                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
4385                         }
4386                         ndr->flags = _flags_save_string;
4387                 }
4388                 {
4389                         uint32_t _flags_save_string = ndr->flags;
4390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4391                         if (r->data_type) {
4392                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
4393                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
4394                         }
4395                         ndr->flags = _flags_save_string;
4396                 }
4397                 {
4398                         uint32_t _flags_save_string = ndr->flags;
4399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4400                         if (r->print_processor) {
4401                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
4402                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
4403                         }
4404                         ndr->flags = _flags_save_string;
4405                 }
4406                 {
4407                         uint32_t _flags_save_string = ndr->flags;
4408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4409                         if (r->parameters) {
4410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
4411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
4412                         }
4413                         ndr->flags = _flags_save_string;
4414                 }
4415                 {
4416                         uint32_t _flags_save_string = ndr->flags;
4417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4418                         if (r->driver_name) {
4419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4421                         }
4422                         ndr->flags = _flags_save_string;
4423                 }
4424                 if (r->devmode) {
4425                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
4426                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4427                 }
4428                 {
4429                         uint32_t _flags_save_string = ndr->flags;
4430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4431                         if (r->text_status) {
4432                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
4433                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 if (r->secdesc) {
4438                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
4439                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4440                 }
4441         }
4442         return NDR_ERR_SUCCESS;
4443 }
4444
4445 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
4446 {
4447         uint32_t _ptr_printer_name;
4448         TALLOC_CTX *_mem_save_printer_name_0;
4449         uint32_t _ptr_server_name;
4450         TALLOC_CTX *_mem_save_server_name_0;
4451         uint32_t _ptr_user_name;
4452         TALLOC_CTX *_mem_save_user_name_0;
4453         uint32_t _ptr_document_name;
4454         TALLOC_CTX *_mem_save_document_name_0;
4455         uint32_t _ptr_notify_name;
4456         TALLOC_CTX *_mem_save_notify_name_0;
4457         uint32_t _ptr_data_type;
4458         TALLOC_CTX *_mem_save_data_type_0;
4459         uint32_t _ptr_print_processor;
4460         TALLOC_CTX *_mem_save_print_processor_0;
4461         uint32_t _ptr_parameters;
4462         TALLOC_CTX *_mem_save_parameters_0;
4463         uint32_t _ptr_driver_name;
4464         TALLOC_CTX *_mem_save_driver_name_0;
4465         uint32_t _ptr_devmode;
4466         TALLOC_CTX *_mem_save_devmode_0;
4467         uint32_t _ptr_text_status;
4468         TALLOC_CTX *_mem_save_text_status_0;
4469         uint32_t _ptr_secdesc;
4470         TALLOC_CTX *_mem_save_secdesc_0;
4471         if (ndr_flags & NDR_SCALARS) {
4472                 NDR_CHECK(ndr_pull_align(ndr, 5));
4473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4474                 {
4475                         uint32_t _flags_save_string = ndr->flags;
4476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4477                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4478                         if (_ptr_printer_name) {
4479                                 NDR_PULL_ALLOC(ndr, r->printer_name);
4480                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
4481                         } else {
4482                                 r->printer_name = NULL;
4483                         }
4484                         ndr->flags = _flags_save_string;
4485                 }
4486                 {
4487                         uint32_t _flags_save_string = ndr->flags;
4488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4489                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4490                         if (_ptr_server_name) {
4491                                 NDR_PULL_ALLOC(ndr, r->server_name);
4492                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
4493                         } else {
4494                                 r->server_name = NULL;
4495                         }
4496                         ndr->flags = _flags_save_string;
4497                 }
4498                 {
4499                         uint32_t _flags_save_string = ndr->flags;
4500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4501                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4502                         if (_ptr_user_name) {
4503                                 NDR_PULL_ALLOC(ndr, r->user_name);
4504                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
4505                         } else {
4506                                 r->user_name = NULL;
4507                         }
4508                         ndr->flags = _flags_save_string;
4509                 }
4510                 {
4511                         uint32_t _flags_save_string = ndr->flags;
4512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4513                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4514                         if (_ptr_document_name) {
4515                                 NDR_PULL_ALLOC(ndr, r->document_name);
4516                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
4517                         } else {
4518                                 r->document_name = NULL;
4519                         }
4520                         ndr->flags = _flags_save_string;
4521                 }
4522                 {
4523                         uint32_t _flags_save_string = ndr->flags;
4524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4525                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4526                         if (_ptr_notify_name) {
4527                                 NDR_PULL_ALLOC(ndr, r->notify_name);
4528                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
4529                         } else {
4530                                 r->notify_name = NULL;
4531                         }
4532                         ndr->flags = _flags_save_string;
4533                 }
4534                 {
4535                         uint32_t _flags_save_string = ndr->flags;
4536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4538                         if (_ptr_data_type) {
4539                                 NDR_PULL_ALLOC(ndr, r->data_type);
4540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
4541                         } else {
4542                                 r->data_type = NULL;
4543                         }
4544                         ndr->flags = _flags_save_string;
4545                 }
4546                 {
4547                         uint32_t _flags_save_string = ndr->flags;
4548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4550                         if (_ptr_print_processor) {
4551                                 NDR_PULL_ALLOC(ndr, r->print_processor);
4552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
4553                         } else {
4554                                 r->print_processor = NULL;
4555                         }
4556                         ndr->flags = _flags_save_string;
4557                 }
4558                 {
4559                         uint32_t _flags_save_string = ndr->flags;
4560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4562                         if (_ptr_parameters) {
4563                                 NDR_PULL_ALLOC(ndr, r->parameters);
4564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
4565                         } else {
4566                                 r->parameters = NULL;
4567                         }
4568                         ndr->flags = _flags_save_string;
4569                 }
4570                 {
4571                         uint32_t _flags_save_string = ndr->flags;
4572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4573                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4574                         if (_ptr_driver_name) {
4575                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4576                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4577                         } else {
4578                                 r->driver_name = NULL;
4579                         }
4580                         ndr->flags = _flags_save_string;
4581                 }
4582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4583                 if (_ptr_devmode) {
4584                         NDR_PULL_ALLOC(ndr, r->devmode);
4585                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
4586                 } else {
4587                         r->devmode = NULL;
4588                 }
4589                 {
4590                         uint32_t _flags_save_string = ndr->flags;
4591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4593                         if (_ptr_text_status) {
4594                                 NDR_PULL_ALLOC(ndr, r->text_status);
4595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
4596                         } else {
4597                                 r->text_status = NULL;
4598                         }
4599                         ndr->flags = _flags_save_string;
4600                 }
4601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4602                 if (_ptr_secdesc) {
4603                         NDR_PULL_ALLOC(ndr, r->secdesc);
4604                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
4605                 } else {
4606                         r->secdesc = NULL;
4607                 }
4608                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4610                 if (r->priority > 99) {
4611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4612                 }
4613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4618                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
4622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4623         }
4624         if (ndr_flags & NDR_BUFFERS) {
4625                 {
4626                         uint32_t _flags_save_string = ndr->flags;
4627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4628                         if (r->printer_name) {
4629                                 uint32_t _relative_save_offset;
4630                                 _relative_save_offset = ndr->offset;
4631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
4632                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4633                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4636                                 if (ndr->offset > ndr->relative_highest_offset) {
4637                                         ndr->relative_highest_offset = ndr->offset;
4638                                 }
4639                                 ndr->offset = _relative_save_offset;
4640                         }
4641                         ndr->flags = _flags_save_string;
4642                 }
4643                 {
4644                         uint32_t _flags_save_string = ndr->flags;
4645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4646                         if (r->server_name) {
4647                                 uint32_t _relative_save_offset;
4648                                 _relative_save_offset = ndr->offset;
4649                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4650                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4651                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4652                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4653                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4654                                 if (ndr->offset > ndr->relative_highest_offset) {
4655                                         ndr->relative_highest_offset = ndr->offset;
4656                                 }
4657                                 ndr->offset = _relative_save_offset;
4658                         }
4659                         ndr->flags = _flags_save_string;
4660                 }
4661                 {
4662                         uint32_t _flags_save_string = ndr->flags;
4663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4664                         if (r->user_name) {
4665                                 uint32_t _relative_save_offset;
4666                                 _relative_save_offset = ndr->offset;
4667                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4668                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4669                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4670                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4671                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4672                                 if (ndr->offset > ndr->relative_highest_offset) {
4673                                         ndr->relative_highest_offset = ndr->offset;
4674                                 }
4675                                 ndr->offset = _relative_save_offset;
4676                         }
4677                         ndr->flags = _flags_save_string;
4678                 }
4679                 {
4680                         uint32_t _flags_save_string = ndr->flags;
4681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4682                         if (r->document_name) {
4683                                 uint32_t _relative_save_offset;
4684                                 _relative_save_offset = ndr->offset;
4685                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4686                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4687                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4690                                 if (ndr->offset > ndr->relative_highest_offset) {
4691                                         ndr->relative_highest_offset = ndr->offset;
4692                                 }
4693                                 ndr->offset = _relative_save_offset;
4694                         }
4695                         ndr->flags = _flags_save_string;
4696                 }
4697                 {
4698                         uint32_t _flags_save_string = ndr->flags;
4699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4700                         if (r->notify_name) {
4701                                 uint32_t _relative_save_offset;
4702                                 _relative_save_offset = ndr->offset;
4703                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4704                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4705                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4706                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4707                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4708                                 if (ndr->offset > ndr->relative_highest_offset) {
4709                                         ndr->relative_highest_offset = ndr->offset;
4710                                 }
4711                                 ndr->offset = _relative_save_offset;
4712                         }
4713                         ndr->flags = _flags_save_string;
4714                 }
4715                 {
4716                         uint32_t _flags_save_string = ndr->flags;
4717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4718                         if (r->data_type) {
4719                                 uint32_t _relative_save_offset;
4720                                 _relative_save_offset = ndr->offset;
4721                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4722                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4723                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4724                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4725                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4726                                 if (ndr->offset > ndr->relative_highest_offset) {
4727                                         ndr->relative_highest_offset = ndr->offset;
4728                                 }
4729                                 ndr->offset = _relative_save_offset;
4730                         }
4731                         ndr->flags = _flags_save_string;
4732                 }
4733                 {
4734                         uint32_t _flags_save_string = ndr->flags;
4735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4736                         if (r->print_processor) {
4737                                 uint32_t _relative_save_offset;
4738                                 _relative_save_offset = ndr->offset;
4739                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4740                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4741                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4742                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4743                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4744                                 if (ndr->offset > ndr->relative_highest_offset) {
4745                                         ndr->relative_highest_offset = ndr->offset;
4746                                 }
4747                                 ndr->offset = _relative_save_offset;
4748                         }
4749                         ndr->flags = _flags_save_string;
4750                 }
4751                 {
4752                         uint32_t _flags_save_string = ndr->flags;
4753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4754                         if (r->parameters) {
4755                                 uint32_t _relative_save_offset;
4756                                 _relative_save_offset = ndr->offset;
4757                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4758                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4759                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4760                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4761                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4762                                 if (ndr->offset > ndr->relative_highest_offset) {
4763                                         ndr->relative_highest_offset = ndr->offset;
4764                                 }
4765                                 ndr->offset = _relative_save_offset;
4766                         }
4767                         ndr->flags = _flags_save_string;
4768                 }
4769                 {
4770                         uint32_t _flags_save_string = ndr->flags;
4771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4772                         if (r->driver_name) {
4773                                 uint32_t _relative_save_offset;
4774                                 _relative_save_offset = ndr->offset;
4775                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4776                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4777                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4778                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4779                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4780                                 if (ndr->offset > ndr->relative_highest_offset) {
4781                                         ndr->relative_highest_offset = ndr->offset;
4782                                 }
4783                                 ndr->offset = _relative_save_offset;
4784                         }
4785                         ndr->flags = _flags_save_string;
4786                 }
4787                 if (r->devmode) {
4788                         uint32_t _relative_save_offset;
4789                         _relative_save_offset = ndr->offset;
4790                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4791                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4793                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4795                         if (ndr->offset > ndr->relative_highest_offset) {
4796                                 ndr->relative_highest_offset = ndr->offset;
4797                         }
4798                         ndr->offset = _relative_save_offset;
4799                 }
4800                 {
4801                         uint32_t _flags_save_string = ndr->flags;
4802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4803                         if (r->text_status) {
4804                                 uint32_t _relative_save_offset;
4805                                 _relative_save_offset = ndr->offset;
4806                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4807                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4808                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4809                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4810                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4811                                 if (ndr->offset > ndr->relative_highest_offset) {
4812                                         ndr->relative_highest_offset = ndr->offset;
4813                                 }
4814                                 ndr->offset = _relative_save_offset;
4815                         }
4816                         ndr->flags = _flags_save_string;
4817                 }
4818                 if (r->secdesc) {
4819                         uint32_t _relative_save_offset;
4820                         _relative_save_offset = ndr->offset;
4821                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4822                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4823                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4824                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4826                         if (ndr->offset > ndr->relative_highest_offset) {
4827                                 ndr->relative_highest_offset = ndr->offset;
4828                         }
4829                         ndr->offset = _relative_save_offset;
4830                 }
4831         }
4832         return NDR_ERR_SUCCESS;
4833 }
4834
4835 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4836 {
4837         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4838         ndr->depth++;
4839         ndr_print_uint32(ndr, "job_id", r->job_id);
4840         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4841         ndr->depth++;
4842         if (r->printer_name) {
4843                 ndr_print_string(ndr, "printer_name", r->printer_name);
4844         }
4845         ndr->depth--;
4846         ndr_print_ptr(ndr, "server_name", r->server_name);
4847         ndr->depth++;
4848         if (r->server_name) {
4849                 ndr_print_string(ndr, "server_name", r->server_name);
4850         }
4851         ndr->depth--;
4852         ndr_print_ptr(ndr, "user_name", r->user_name);
4853         ndr->depth++;
4854         if (r->user_name) {
4855                 ndr_print_string(ndr, "user_name", r->user_name);
4856         }
4857         ndr->depth--;
4858         ndr_print_ptr(ndr, "document_name", r->document_name);
4859         ndr->depth++;
4860         if (r->document_name) {
4861                 ndr_print_string(ndr, "document_name", r->document_name);
4862         }
4863         ndr->depth--;
4864         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4865         ndr->depth++;
4866         if (r->notify_name) {
4867                 ndr_print_string(ndr, "notify_name", r->notify_name);
4868         }
4869         ndr->depth--;
4870         ndr_print_ptr(ndr, "data_type", r->data_type);
4871         ndr->depth++;
4872         if (r->data_type) {
4873                 ndr_print_string(ndr, "data_type", r->data_type);
4874         }
4875         ndr->depth--;
4876         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4877         ndr->depth++;
4878         if (r->print_processor) {
4879                 ndr_print_string(ndr, "print_processor", r->print_processor);
4880         }
4881         ndr->depth--;
4882         ndr_print_ptr(ndr, "parameters", r->parameters);
4883         ndr->depth++;
4884         if (r->parameters) {
4885                 ndr_print_string(ndr, "parameters", r->parameters);
4886         }
4887         ndr->depth--;
4888         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4889         ndr->depth++;
4890         if (r->driver_name) {
4891                 ndr_print_string(ndr, "driver_name", r->driver_name);
4892         }
4893         ndr->depth--;
4894         ndr_print_ptr(ndr, "devmode", r->devmode);
4895         ndr->depth++;
4896         if (r->devmode) {
4897                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4898         }
4899         ndr->depth--;
4900         ndr_print_ptr(ndr, "text_status", r->text_status);
4901         ndr->depth++;
4902         if (r->text_status) {
4903                 ndr_print_string(ndr, "text_status", r->text_status);
4904         }
4905         ndr->depth--;
4906         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4907         ndr->depth++;
4908         if (r->secdesc) {
4909                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4910         }
4911         ndr->depth--;
4912         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4913         ndr_print_uint32(ndr, "priority", r->priority);
4914         ndr_print_uint32(ndr, "position", r->position);
4915         ndr_print_uint32(ndr, "start_time", r->start_time);
4916         ndr_print_uint32(ndr, "until_time", r->until_time);
4917         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4918         ndr_print_uint32(ndr, "size", r->size);
4919         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4920         ndr_print_uint32(ndr, "time", r->time);
4921         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4922         ndr_print_uint32(ndr, "size_high", r->size_high);
4923         ndr->depth--;
4924 }
4925
4926 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4927 {
4928         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4929 }
4930
4931 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4932 {
4933         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4934         if (ndr_flags & NDR_SCALARS) {
4935                 int level = ndr_push_get_switch_value(ndr, r);
4936                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4937                 switch (level) {
4938                         case 1: {
4939                                 NDR_CHECK(ndr_push_align(ndr, 5));
4940                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4941                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4942                         break; }
4943
4944                         case 2: {
4945                                 NDR_CHECK(ndr_push_align(ndr, 5));
4946                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4947                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4948                         break; }
4949
4950                         case 3: {
4951                                 NDR_CHECK(ndr_push_align(ndr, 4));
4952                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4953                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4954                         break; }
4955
4956                         case 4: {
4957                                 NDR_CHECK(ndr_push_align(ndr, 5));
4958                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4959                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4960                         break; }
4961
4962                         default: {
4963                         break; }
4964
4965                 }
4966         }
4967         if (ndr_flags & NDR_BUFFERS) {
4968                 int level = ndr_push_get_switch_value(ndr, r);
4969                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4970                 switch (level) {
4971                         case 1:
4972                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4973                         break;
4974
4975                         case 2:
4976                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4977                         break;
4978
4979                         case 3:
4980                         break;
4981
4982                         case 4:
4983                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4984                         break;
4985
4986                         default:
4987                         break;
4988
4989                 }
4990         }
4991         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4992         return NDR_ERR_SUCCESS;
4993 }
4994
4995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4996 {
4997         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4998         int level;
4999         level = ndr_pull_get_switch_value(ndr, r);
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5002                 switch (level) {
5003                         case 1: {
5004                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5005                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5006                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
5007                         break; }
5008
5009                         case 2: {
5010                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5011                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5012                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
5013                         break; }
5014
5015                         case 3: {
5016                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5017                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5018                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
5019                         break; }
5020
5021                         case 4: {
5022                                 NDR_CHECK(ndr_pull_align(ndr, 5));
5023                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5024                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
5025                         break; }
5026
5027                         default: {
5028                         break; }
5029
5030                 }
5031         }
5032         if (ndr_flags & NDR_BUFFERS) {
5033                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5034                 switch (level) {
5035                         case 1:
5036                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
5037                         break;
5038
5039                         case 2:
5040                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
5041                         break;
5042
5043                         case 3:
5044                         break;
5045
5046                         case 4:
5047                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
5048                         break;
5049
5050                         default:
5051                         break;
5052
5053                 }
5054         }
5055         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5056         return NDR_ERR_SUCCESS;
5057 }
5058
5059 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
5060 {
5061         int level;
5062         level = ndr_print_get_switch_value(ndr, r);
5063         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
5064         switch (level) {
5065                 case 1:
5066                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
5067                 break;
5068
5069                 case 2:
5070                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
5071                 break;
5072
5073                 case 3:
5074                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
5075                 break;
5076
5077                 case 4:
5078                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
5079                 break;
5080
5081                 default:
5082                 break;
5083
5084         }
5085 }
5086
5087 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
5088 {
5089         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
5090 }
5091
5092 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
5093 {
5094         if (ndr_flags & NDR_SCALARS) {
5095                 NDR_CHECK(ndr_push_align(ndr, 5));
5096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5103                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5108                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5109                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5110         }
5111         if (ndr_flags & NDR_BUFFERS) {
5112                 if (r->printer_name) {
5113                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5115                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5116                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5117                 }
5118                 if (r->server_name) {
5119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5122                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5123                 }
5124                 if (r->user_name) {
5125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5128                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5129                 }
5130                 if (r->document_name) {
5131                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5134                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5135                 }
5136                 if (r->data_type) {
5137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5141                 }
5142                 if (r->text_status) {
5143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5146                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5147                 }
5148         }
5149         return NDR_ERR_SUCCESS;
5150 }
5151
5152 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
5153 {
5154         uint32_t _ptr_printer_name;
5155         TALLOC_CTX *_mem_save_printer_name_0;
5156         uint32_t _ptr_server_name;
5157         TALLOC_CTX *_mem_save_server_name_0;
5158         uint32_t _ptr_user_name;
5159         TALLOC_CTX *_mem_save_user_name_0;
5160         uint32_t _ptr_document_name;
5161         TALLOC_CTX *_mem_save_document_name_0;
5162         uint32_t _ptr_data_type;
5163         TALLOC_CTX *_mem_save_data_type_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 5));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5194                 if (_ptr_data_type) {
5195                         NDR_PULL_ALLOC(ndr, r->data_type);
5196                 } else {
5197                         r->data_type = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5200                 if (_ptr_text_status) {
5201                         NDR_PULL_ALLOC(ndr, r->text_status);
5202                 } else {
5203                         r->text_status = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5207                 if (r->priority > 99) {
5208                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5209                 }
5210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5213                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5214                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5215         }
5216         if (ndr_flags & NDR_BUFFERS) {
5217                 if (r->printer_name) {
5218                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5219                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5222                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5224                         }
5225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5228                 }
5229                 if (r->server_name) {
5230                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5231                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5234                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5236                         }
5237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5240                 }
5241                 if (r->user_name) {
5242                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5243                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5246                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5248                         }
5249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5252                 }
5253                 if (r->document_name) {
5254                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5255                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5258                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5260                         }
5261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5264                 }
5265                 if (r->data_type) {
5266                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5270                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5276                 }
5277                 if (r->text_status) {
5278                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5282                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5288                 }
5289         }
5290         return NDR_ERR_SUCCESS;
5291 }
5292
5293 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
5294 {
5295         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
5296         ndr->depth++;
5297         ndr_print_uint32(ndr, "job_id", r->job_id);
5298         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5299         ndr->depth++;
5300         if (r->printer_name) {
5301                 ndr_print_string(ndr, "printer_name", r->printer_name);
5302         }
5303         ndr->depth--;
5304         ndr_print_ptr(ndr, "server_name", r->server_name);
5305         ndr->depth++;
5306         if (r->server_name) {
5307                 ndr_print_string(ndr, "server_name", r->server_name);
5308         }
5309         ndr->depth--;
5310         ndr_print_ptr(ndr, "user_name", r->user_name);
5311         ndr->depth++;
5312         if (r->user_name) {
5313                 ndr_print_string(ndr, "user_name", r->user_name);
5314         }
5315         ndr->depth--;
5316         ndr_print_ptr(ndr, "document_name", r->document_name);
5317         ndr->depth++;
5318         if (r->document_name) {
5319                 ndr_print_string(ndr, "document_name", r->document_name);
5320         }
5321         ndr->depth--;
5322         ndr_print_ptr(ndr, "data_type", r->data_type);
5323         ndr->depth++;
5324         if (r->data_type) {
5325                 ndr_print_string(ndr, "data_type", r->data_type);
5326         }
5327         ndr->depth--;
5328         ndr_print_ptr(ndr, "text_status", r->text_status);
5329         ndr->depth++;
5330         if (r->text_status) {
5331                 ndr_print_string(ndr, "text_status", r->text_status);
5332         }
5333         ndr->depth--;
5334         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5335         ndr_print_uint32(ndr, "priority", r->priority);
5336         ndr_print_uint32(ndr, "position", r->position);
5337         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5338         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5339         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5340         ndr->depth--;
5341 }
5342
5343 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
5344 {
5345         if (ndr_flags & NDR_SCALARS) {
5346                 NDR_CHECK(ndr_push_align(ndr, 5));
5347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5360                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5367                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5370                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5371         }
5372         if (ndr_flags & NDR_BUFFERS) {
5373                 if (r->printer_name) {
5374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5378                 }
5379                 if (r->server_name) {
5380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5384                 }
5385                 if (r->user_name) {
5386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5390                 }
5391                 if (r->document_name) {
5392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5394                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5396                 }
5397                 if (r->notify_name) {
5398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5402                 }
5403                 if (r->data_type) {
5404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5406                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5408                 }
5409                 if (r->print_processor) {
5410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5414                 }
5415                 if (r->parameters) {
5416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5420                 }
5421                 if (r->driver_name) {
5422                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5423                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5426                 }
5427                 if (r->text_status) {
5428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5430                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5432                 }
5433         }
5434         return NDR_ERR_SUCCESS;
5435 }
5436
5437 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
5438 {
5439         uint32_t _ptr_printer_name;
5440         TALLOC_CTX *_mem_save_printer_name_0;
5441         uint32_t _ptr_server_name;
5442         TALLOC_CTX *_mem_save_server_name_0;
5443         uint32_t _ptr_user_name;
5444         TALLOC_CTX *_mem_save_user_name_0;
5445         uint32_t _ptr_document_name;
5446         TALLOC_CTX *_mem_save_document_name_0;
5447         uint32_t _ptr_notify_name;
5448         TALLOC_CTX *_mem_save_notify_name_0;
5449         uint32_t _ptr_data_type;
5450         TALLOC_CTX *_mem_save_data_type_0;
5451         uint32_t _ptr_print_processor;
5452         TALLOC_CTX *_mem_save_print_processor_0;
5453         uint32_t _ptr_parameters;
5454         TALLOC_CTX *_mem_save_parameters_0;
5455         uint32_t _ptr_driver_name;
5456         TALLOC_CTX *_mem_save_driver_name_0;
5457         uint32_t _ptr_text_status;
5458         TALLOC_CTX *_mem_save_text_status_0;
5459         if (ndr_flags & NDR_SCALARS) {
5460                 NDR_CHECK(ndr_pull_align(ndr, 5));
5461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5463                 if (_ptr_printer_name) {
5464                         NDR_PULL_ALLOC(ndr, r->printer_name);
5465                 } else {
5466                         r->printer_name = NULL;
5467                 }
5468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5469                 if (_ptr_server_name) {
5470                         NDR_PULL_ALLOC(ndr, r->server_name);
5471                 } else {
5472                         r->server_name = NULL;
5473                 }
5474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5475                 if (_ptr_user_name) {
5476                         NDR_PULL_ALLOC(ndr, r->user_name);
5477                 } else {
5478                         r->user_name = NULL;
5479                 }
5480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5481                 if (_ptr_document_name) {
5482                         NDR_PULL_ALLOC(ndr, r->document_name);
5483                 } else {
5484                         r->document_name = NULL;
5485                 }
5486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5487                 if (_ptr_notify_name) {
5488                         NDR_PULL_ALLOC(ndr, r->notify_name);
5489                 } else {
5490                         r->notify_name = NULL;
5491                 }
5492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5493                 if (_ptr_data_type) {
5494                         NDR_PULL_ALLOC(ndr, r->data_type);
5495                 } else {
5496                         r->data_type = NULL;
5497                 }
5498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5499                 if (_ptr_print_processor) {
5500                         NDR_PULL_ALLOC(ndr, r->print_processor);
5501                 } else {
5502                         r->print_processor = NULL;
5503                 }
5504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5505                 if (_ptr_parameters) {
5506                         NDR_PULL_ALLOC(ndr, r->parameters);
5507                 } else {
5508                         r->parameters = NULL;
5509                 }
5510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5511                 if (_ptr_driver_name) {
5512                         NDR_PULL_ALLOC(ndr, r->driver_name);
5513                 } else {
5514                         r->driver_name = NULL;
5515                 }
5516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5518                 if (_ptr_text_status) {
5519                         NDR_PULL_ALLOC(ndr, r->text_status);
5520                 } else {
5521                         r->text_status = NULL;
5522                 }
5523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5524                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5526                 if (r->priority > 99) {
5527                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5528                 }
5529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5534                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5538         }
5539         if (ndr_flags & NDR_BUFFERS) {
5540                 if (r->printer_name) {
5541                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5542                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5545                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5546                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5547                         }
5548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5551                 }
5552                 if (r->server_name) {
5553                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5557                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5558                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5559                         }
5560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5563                 }
5564                 if (r->user_name) {
5565                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5566                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5569                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5570                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5571                         }
5572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5575                 }
5576                 if (r->document_name) {
5577                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5578                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5581                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5582                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5583                         }
5584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5587                 }
5588                 if (r->notify_name) {
5589                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5590                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5593                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5594                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5595                         }
5596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5599                 }
5600                 if (r->data_type) {
5601                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5602                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5603                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5604                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5605                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5606                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5607                         }
5608                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5609                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5610                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5611                 }
5612                 if (r->print_processor) {
5613                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5617                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5618                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5619                         }
5620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5623                 }
5624                 if (r->parameters) {
5625                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5626                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5627                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5628                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5629                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5630                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5631                         }
5632                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5633                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5635                 }
5636                 if (r->driver_name) {
5637                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5638                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5641                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5642                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5643                         }
5644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5647                 }
5648                 if (r->text_status) {
5649                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5650                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5653                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5654                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5655                         }
5656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5659                 }
5660         }
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
5665 {
5666         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
5667         ndr->depth++;
5668         ndr_print_uint32(ndr, "job_id", r->job_id);
5669         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5670         ndr->depth++;
5671         if (r->printer_name) {
5672                 ndr_print_string(ndr, "printer_name", r->printer_name);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "server_name", r->server_name);
5676         ndr->depth++;
5677         if (r->server_name) {
5678                 ndr_print_string(ndr, "server_name", r->server_name);
5679         }
5680         ndr->depth--;
5681         ndr_print_ptr(ndr, "user_name", r->user_name);
5682         ndr->depth++;
5683         if (r->user_name) {
5684                 ndr_print_string(ndr, "user_name", r->user_name);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "document_name", r->document_name);
5688         ndr->depth++;
5689         if (r->document_name) {
5690                 ndr_print_string(ndr, "document_name", r->document_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5694         ndr->depth++;
5695         if (r->notify_name) {
5696                 ndr_print_string(ndr, "notify_name", r->notify_name);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "data_type", r->data_type);
5700         ndr->depth++;
5701         if (r->data_type) {
5702                 ndr_print_string(ndr, "data_type", r->data_type);
5703         }
5704         ndr->depth--;
5705         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5706         ndr->depth++;
5707         if (r->print_processor) {
5708                 ndr_print_string(ndr, "print_processor", r->print_processor);
5709         }
5710         ndr->depth--;
5711         ndr_print_ptr(ndr, "parameters", r->parameters);
5712         ndr->depth++;
5713         if (r->parameters) {
5714                 ndr_print_string(ndr, "parameters", r->parameters);
5715         }
5716         ndr->depth--;
5717         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5718         ndr->depth++;
5719         if (r->driver_name) {
5720                 ndr_print_string(ndr, "driver_name", r->driver_name);
5721         }
5722         ndr->depth--;
5723         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5724         ndr_print_ptr(ndr, "text_status", r->text_status);
5725         ndr->depth++;
5726         if (r->text_status) {
5727                 ndr_print_string(ndr, "text_status", r->text_status);
5728         }
5729         ndr->depth--;
5730         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5731         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5732         ndr_print_uint32(ndr, "priority", r->priority);
5733         ndr_print_uint32(ndr, "position", r->position);
5734         ndr_print_uint32(ndr, "start_time", r->start_time);
5735         ndr_print_uint32(ndr, "until_time", r->until_time);
5736         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5737         ndr_print_uint32(ndr, "size", r->size);
5738         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5739         ndr_print_uint32(ndr, "time", r->time);
5740         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5741         ndr->depth--;
5742 }
5743
5744 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5745 {
5746         if (ndr_flags & NDR_SCALARS) {
5747                 NDR_CHECK(ndr_push_align(ndr, 5));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5761                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5768                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5772                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5773         }
5774         if (ndr_flags & NDR_BUFFERS) {
5775                 if (r->printer_name) {
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781                 if (r->server_name) {
5782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5786                 }
5787                 if (r->user_name) {
5788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5792                 }
5793                 if (r->document_name) {
5794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5798                 }
5799                 if (r->notify_name) {
5800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5804                 }
5805                 if (r->data_type) {
5806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5810                 }
5811                 if (r->print_processor) {
5812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5816                 }
5817                 if (r->parameters) {
5818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5822                 }
5823                 if (r->driver_name) {
5824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5828                 }
5829                 if (r->text_status) {
5830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5833                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5834                 }
5835         }
5836         return NDR_ERR_SUCCESS;
5837 }
5838
5839 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5840 {
5841         uint32_t _ptr_printer_name;
5842         TALLOC_CTX *_mem_save_printer_name_0;
5843         uint32_t _ptr_server_name;
5844         TALLOC_CTX *_mem_save_server_name_0;
5845         uint32_t _ptr_user_name;
5846         TALLOC_CTX *_mem_save_user_name_0;
5847         uint32_t _ptr_document_name;
5848         TALLOC_CTX *_mem_save_document_name_0;
5849         uint32_t _ptr_notify_name;
5850         TALLOC_CTX *_mem_save_notify_name_0;
5851         uint32_t _ptr_data_type;
5852         TALLOC_CTX *_mem_save_data_type_0;
5853         uint32_t _ptr_print_processor;
5854         TALLOC_CTX *_mem_save_print_processor_0;
5855         uint32_t _ptr_parameters;
5856         TALLOC_CTX *_mem_save_parameters_0;
5857         uint32_t _ptr_driver_name;
5858         TALLOC_CTX *_mem_save_driver_name_0;
5859         uint32_t _ptr_text_status;
5860         TALLOC_CTX *_mem_save_text_status_0;
5861         if (ndr_flags & NDR_SCALARS) {
5862                 NDR_CHECK(ndr_pull_align(ndr, 5));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5865                 if (_ptr_printer_name) {
5866                         NDR_PULL_ALLOC(ndr, r->printer_name);
5867                 } else {
5868                         r->printer_name = NULL;
5869                 }
5870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5871                 if (_ptr_server_name) {
5872                         NDR_PULL_ALLOC(ndr, r->server_name);
5873                 } else {
5874                         r->server_name = NULL;
5875                 }
5876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5877                 if (_ptr_user_name) {
5878                         NDR_PULL_ALLOC(ndr, r->user_name);
5879                 } else {
5880                         r->user_name = NULL;
5881                 }
5882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5883                 if (_ptr_document_name) {
5884                         NDR_PULL_ALLOC(ndr, r->document_name);
5885                 } else {
5886                         r->document_name = NULL;
5887                 }
5888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5889                 if (_ptr_notify_name) {
5890                         NDR_PULL_ALLOC(ndr, r->notify_name);
5891                 } else {
5892                         r->notify_name = NULL;
5893                 }
5894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5895                 if (_ptr_data_type) {
5896                         NDR_PULL_ALLOC(ndr, r->data_type);
5897                 } else {
5898                         r->data_type = NULL;
5899                 }
5900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5901                 if (_ptr_print_processor) {
5902                         NDR_PULL_ALLOC(ndr, r->print_processor);
5903                 } else {
5904                         r->print_processor = NULL;
5905                 }
5906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5907                 if (_ptr_parameters) {
5908                         NDR_PULL_ALLOC(ndr, r->parameters);
5909                 } else {
5910                         r->parameters = NULL;
5911                 }
5912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5913                 if (_ptr_driver_name) {
5914                         NDR_PULL_ALLOC(ndr, r->driver_name);
5915                 } else {
5916                         r->driver_name = NULL;
5917                 }
5918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5920                 if (_ptr_text_status) {
5921                         NDR_PULL_ALLOC(ndr, r->text_status);
5922                 } else {
5923                         r->text_status = NULL;
5924                 }
5925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5926                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5928                 if (r->priority > 99) {
5929                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5930                 }
5931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5936                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5938                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5940                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5941         }
5942         if (ndr_flags & NDR_BUFFERS) {
5943                 if (r->printer_name) {
5944                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5945                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5948                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5949                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5950                         }
5951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5954                 }
5955                 if (r->server_name) {
5956                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5960                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5966                 }
5967                 if (r->user_name) {
5968                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5972                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5978                 }
5979                 if (r->document_name) {
5980                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5984                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5990                 }
5991                 if (r->notify_name) {
5992                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5993                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5996                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5997                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5998                         }
5999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
6000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
6001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
6002                 }
6003                 if (r->data_type) {
6004                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
6005                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
6006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
6007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
6008                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
6009                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
6010                         }
6011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
6012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
6013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
6014                 }
6015                 if (r->print_processor) {
6016                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6017                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
6018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
6019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
6020                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
6021                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
6022                         }
6023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
6024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
6025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
6026                 }
6027                 if (r->parameters) {
6028                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6032                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6033                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6034                         }
6035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6038                 }
6039                 if (r->driver_name) {
6040                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6044                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6045                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
6046                         }
6047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6050                 }
6051                 if (r->text_status) {
6052                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
6053                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
6054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
6055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
6056                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
6057                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
6058                         }
6059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
6060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
6061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
6062                 }
6063         }
6064         return NDR_ERR_SUCCESS;
6065 }
6066
6067 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
6068 {
6069         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
6070         ndr->depth++;
6071         ndr_print_uint32(ndr, "job_id", r->job_id);
6072         ndr_print_ptr(ndr, "printer_name", r->printer_name);
6073         ndr->depth++;
6074         if (r->printer_name) {
6075                 ndr_print_string(ndr, "printer_name", r->printer_name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "server_name", r->server_name);
6079         ndr->depth++;
6080         if (r->server_name) {
6081                 ndr_print_string(ndr, "server_name", r->server_name);
6082         }
6083         ndr->depth--;
6084         ndr_print_ptr(ndr, "user_name", r->user_name);
6085         ndr->depth++;
6086         if (r->user_name) {
6087                 ndr_print_string(ndr, "user_name", r->user_name);
6088         }
6089         ndr->depth--;
6090         ndr_print_ptr(ndr, "document_name", r->document_name);
6091         ndr->depth++;
6092         if (r->document_name) {
6093                 ndr_print_string(ndr, "document_name", r->document_name);
6094         }
6095         ndr->depth--;
6096         ndr_print_ptr(ndr, "notify_name", r->notify_name);
6097         ndr->depth++;
6098         if (r->notify_name) {
6099                 ndr_print_string(ndr, "notify_name", r->notify_name);
6100         }
6101         ndr->depth--;
6102         ndr_print_ptr(ndr, "data_type", r->data_type);
6103         ndr->depth++;
6104         if (r->data_type) {
6105                 ndr_print_string(ndr, "data_type", r->data_type);
6106         }
6107         ndr->depth--;
6108         ndr_print_ptr(ndr, "print_processor", r->print_processor);
6109         ndr->depth++;
6110         if (r->print_processor) {
6111                 ndr_print_string(ndr, "print_processor", r->print_processor);
6112         }
6113         ndr->depth--;
6114         ndr_print_ptr(ndr, "parameters", r->parameters);
6115         ndr->depth++;
6116         if (r->parameters) {
6117                 ndr_print_string(ndr, "parameters", r->parameters);
6118         }
6119         ndr->depth--;
6120         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6121         ndr->depth++;
6122         if (r->driver_name) {
6123                 ndr_print_string(ndr, "driver_name", r->driver_name);
6124         }
6125         ndr->depth--;
6126         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
6127         ndr_print_ptr(ndr, "text_status", r->text_status);
6128         ndr->depth++;
6129         if (r->text_status) {
6130                 ndr_print_string(ndr, "text_status", r->text_status);
6131         }
6132         ndr->depth--;
6133         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
6134         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
6135         ndr_print_uint32(ndr, "priority", r->priority);
6136         ndr_print_uint32(ndr, "position", r->position);
6137         ndr_print_uint32(ndr, "start_time", r->start_time);
6138         ndr_print_uint32(ndr, "until_time", r->until_time);
6139         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6140         ndr_print_uint32(ndr, "size", r->size);
6141         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
6142         ndr_print_uint32(ndr, "time", r->time);
6143         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
6144         ndr_print_uint32(ndr, "size_high", r->size_high);
6145         ndr->depth--;
6146 }
6147
6148 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
6149 {
6150         if (ndr_flags & NDR_SCALARS) {
6151                 int level = ndr_push_get_switch_value(ndr, r);
6152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6153                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6154                 switch (level) {
6155                         case 1: {
6156                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6157                         break; }
6158
6159                         case 2: {
6160                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6161                         break; }
6162
6163                         case 3: {
6164                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6165                         break; }
6166
6167                         case 4: {
6168                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6169                         break; }
6170
6171                         default: {
6172                         break; }
6173
6174                 }
6175         }
6176         if (ndr_flags & NDR_BUFFERS) {
6177                 int level = ndr_push_get_switch_value(ndr, r);
6178                 switch (level) {
6179                         case 1:
6180                                 if (r->info1) {
6181                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6182                                 }
6183                         break;
6184
6185                         case 2:
6186                                 if (r->info2) {
6187                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6188                                 }
6189                         break;
6190
6191                         case 3:
6192                                 if (r->info3) {
6193                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6194                                 }
6195                         break;
6196
6197                         case 4:
6198                                 if (r->info4) {
6199                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6200                                 }
6201                         break;
6202
6203                         default:
6204                         break;
6205
6206                 }
6207         }
6208         return NDR_ERR_SUCCESS;
6209 }
6210
6211 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
6212 {
6213         int level;
6214         uint32_t _level;
6215         TALLOC_CTX *_mem_save_info1_0;
6216         TALLOC_CTX *_mem_save_info2_0;
6217         TALLOC_CTX *_mem_save_info3_0;
6218         TALLOC_CTX *_mem_save_info4_0;
6219         level = ndr_pull_get_switch_value(ndr, r);
6220         if (ndr_flags & NDR_SCALARS) {
6221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6222                 if (_level != level) {
6223                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6224                 }
6225                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6226                 switch (level) {
6227                         case 1: {
6228                                 uint32_t _ptr_info1;
6229                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6230                                 if (_ptr_info1) {
6231                                         NDR_PULL_ALLOC(ndr, r->info1);
6232                                 } else {
6233                                         r->info1 = NULL;
6234                                 }
6235                         break; }
6236
6237                         case 2: {
6238                                 uint32_t _ptr_info2;
6239                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6240                                 if (_ptr_info2) {
6241                                         NDR_PULL_ALLOC(ndr, r->info2);
6242                                 } else {
6243                                         r->info2 = NULL;
6244                                 }
6245                         break; }
6246
6247                         case 3: {
6248                                 uint32_t _ptr_info3;
6249                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
6250                                 if (_ptr_info3) {
6251                                         NDR_PULL_ALLOC(ndr, r->info3);
6252                                 } else {
6253                                         r->info3 = NULL;
6254                                 }
6255                         break; }
6256
6257                         case 4: {
6258                                 uint32_t _ptr_info4;
6259                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
6260                                 if (_ptr_info4) {
6261                                         NDR_PULL_ALLOC(ndr, r->info4);
6262                                 } else {
6263                                         r->info4 = NULL;
6264                                 }
6265                         break; }
6266
6267                         default: {
6268                         break; }
6269
6270                 }
6271         }
6272         if (ndr_flags & NDR_BUFFERS) {
6273                 switch (level) {
6274                         case 1:
6275                                 if (r->info1) {
6276                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6277                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6278                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6279                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6280                                 }
6281                         break;
6282
6283                         case 2:
6284                                 if (r->info2) {
6285                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
6286                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
6287                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6288                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
6289                                 }
6290                         break;
6291
6292                         case 3:
6293                                 if (r->info3) {
6294                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
6295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
6296                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
6297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
6298                                 }
6299                         break;
6300
6301                         case 4:
6302                                 if (r->info4) {
6303                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
6304                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
6305                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6306                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
6307                                 }
6308                         break;
6309
6310                         default:
6311                         break;
6312
6313                 }
6314         }
6315         return NDR_ERR_SUCCESS;
6316 }
6317
6318 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
6319 {
6320         int level;
6321         level = ndr_print_get_switch_value(ndr, r);
6322         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
6323         switch (level) {
6324                 case 1:
6325                         ndr_print_ptr(ndr, "info1", r->info1);
6326                         ndr->depth++;
6327                         if (r->info1) {
6328                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
6329                         }
6330                         ndr->depth--;
6331                 break;
6332
6333                 case 2:
6334                         ndr_print_ptr(ndr, "info2", r->info2);
6335                         ndr->depth++;
6336                         if (r->info2) {
6337                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
6338                         }
6339                         ndr->depth--;
6340                 break;
6341
6342                 case 3:
6343                         ndr_print_ptr(ndr, "info3", r->info3);
6344                         ndr->depth++;
6345                         if (r->info3) {
6346                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
6347                         }
6348                         ndr->depth--;
6349                 break;
6350
6351                 case 4:
6352                         ndr_print_ptr(ndr, "info4", r->info4);
6353                         ndr->depth++;
6354                         if (r->info4) {
6355                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
6356                         }
6357                         ndr->depth--;
6358                 break;
6359
6360                 default:
6361                 break;
6362
6363         }
6364 }
6365
6366 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
6367 {
6368         if (ndr_flags & NDR_SCALARS) {
6369                 NDR_CHECK(ndr_push_align(ndr, 5));
6370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
6371                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
6372                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6373                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6374         }
6375         if (ndr_flags & NDR_BUFFERS) {
6376                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
6382 {
6383         if (ndr_flags & NDR_SCALARS) {
6384                 NDR_CHECK(ndr_pull_align(ndr, 5));
6385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6386                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6387                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
6388                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6389         }
6390         if (ndr_flags & NDR_BUFFERS) {
6391                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
6392         }
6393         return NDR_ERR_SUCCESS;
6394 }
6395
6396 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
6397 {
6398         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
6399         ndr->depth++;
6400         ndr_print_uint32(ndr, "level", r->level);
6401         ndr_print_set_switch_value(ndr, &r->info, r->level);
6402         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
6403         ndr->depth--;
6404 }
6405
6406 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
6407 {
6408         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6409         return NDR_ERR_SUCCESS;
6410 }
6411
6412 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
6413 {
6414         uint32_t v;
6415         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6416         *r = v;
6417         return NDR_ERR_SUCCESS;
6418 }
6419
6420 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
6421 {
6422         const char *val = NULL;
6423
6424         switch (r) {
6425                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
6426                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
6427                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
6428                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
6429                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
6430                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
6431                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
6432                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
6433                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
6434         }
6435         ndr_print_enum(ndr, name, "ENUM", val, r);
6436 }
6437
6438 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
6439 {
6440         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6441         return NDR_ERR_SUCCESS;
6442 }
6443
6444 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
6445 {
6446         uint32_t v;
6447         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6448         *r = v;
6449         return NDR_ERR_SUCCESS;
6450 }
6451
6452 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
6453 {
6454         const char *val = NULL;
6455
6456         switch (r) {
6457                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
6458                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
6459                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
6460                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
6461                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
6462         }
6463         ndr_print_enum(ndr, name, "ENUM", val, r);
6464 }
6465
6466 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
6467 {
6468         if (ndr_flags & NDR_SCALARS) {
6469                 NDR_CHECK(ndr_push_align(ndr, 5));
6470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
6474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
6475                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
6477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
6478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
6479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
6480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
6481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
6482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
6483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
6484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
6485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
6486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
6487                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
6488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
6489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
6490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
6491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
6492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
6494                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
6495                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
6496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
6497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
6498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
6499                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6500         }
6501         if (ndr_flags & NDR_BUFFERS) {
6502                 if (r->servername) {
6503                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6507                 }
6508                 if (r->printername) {
6509                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6513                 }
6514         }
6515         return NDR_ERR_SUCCESS;
6516 }
6517
6518 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
6519 {
6520         uint32_t _ptr_servername;
6521         TALLOC_CTX *_mem_save_servername_0;
6522         uint32_t _ptr_printername;
6523         TALLOC_CTX *_mem_save_printername_0;
6524         if (ndr_flags & NDR_SCALARS) {
6525                 NDR_CHECK(ndr_pull_align(ndr, 5));
6526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6527                 if (_ptr_servername) {
6528                         NDR_PULL_ALLOC(ndr, r->servername);
6529                 } else {
6530                         r->servername = NULL;
6531                 }
6532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6533                 if (_ptr_printername) {
6534                         NDR_PULL_ALLOC(ndr, r->printername);
6535                 } else {
6536                         r->printername = NULL;
6537                 }
6538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
6540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
6541                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
6542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
6543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
6544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
6545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
6546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
6547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
6548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
6549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
6550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
6551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
6552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
6553                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
6554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
6556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
6557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
6558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
6559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
6560                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
6561                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
6562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
6564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
6565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6566         }
6567         if (ndr_flags & NDR_BUFFERS) {
6568                 if (r->servername) {
6569                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6570                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6573                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6575                         }
6576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6579                 }
6580                 if (r->printername) {
6581                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6582                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6585                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6587                         }
6588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6591                 }
6592         }
6593         return NDR_ERR_SUCCESS;
6594 }
6595
6596 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
6597 {
6598         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
6599         ndr->depth++;
6600         ndr_print_ptr(ndr, "servername", r->servername);
6601         ndr->depth++;
6602         if (r->servername) {
6603                 ndr_print_string(ndr, "servername", r->servername);
6604         }
6605         ndr->depth--;
6606         ndr_print_ptr(ndr, "printername", r->printername);
6607         ndr->depth++;
6608         if (r->printername) {
6609                 ndr_print_string(ndr, "printername", r->printername);
6610         }
6611         ndr->depth--;
6612         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6613         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
6614         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
6615         ndr_print_spoolss_Time(ndr, "time", &r->time);
6616         ndr_print_uint32(ndr, "global_counter", r->global_counter);
6617         ndr_print_uint32(ndr, "total_pages", r->total_pages);
6618         ndr_print_uint32(ndr, "version", r->version);
6619         ndr_print_uint32(ndr, "free_build", r->free_build);
6620         ndr_print_uint32(ndr, "spooling", r->spooling);
6621         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
6622         ndr_print_uint32(ndr, "session_counter", r->session_counter);
6623         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
6624         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
6625         ndr_print_uint32(ndr, "job_error", r->job_error);
6626         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
6627         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
6628         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
6629         ndr_print_uint32(ndr, "change_id", r->change_id);
6630         ndr_print_WERROR(ndr, "last_error", r->last_error);
6631         ndr_print_uint32(ndr, "status", r->status);
6632         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
6633         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
6634         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
6635         ndr_print_uint16(ndr, "processor_level", r->processor_level);
6636         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
6637         ndr_print_uint32(ndr, "reserved2", r->reserved2);
6638         ndr_print_uint32(ndr, "reserved3", r->reserved3);
6639         ndr->depth--;
6640 }
6641
6642 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
6643 {
6644         if (ndr_flags & NDR_SCALARS) {
6645                 NDR_CHECK(ndr_push_align(ndr, 5));
6646                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->flags));
6647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
6648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
6649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6651         }
6652         if (ndr_flags & NDR_BUFFERS) {
6653                 if (r->description) {
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
6657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6658                 }
6659                 if (r->name) {
6660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
6663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6664                 }
6665                 if (r->comment) {
6666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6670                 }
6671         }
6672         return NDR_ERR_SUCCESS;
6673 }
6674
6675 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
6676 {
6677         uint32_t _ptr_description;
6678         TALLOC_CTX *_mem_save_description_0;
6679         uint32_t _ptr_name;
6680         TALLOC_CTX *_mem_save_name_0;
6681         uint32_t _ptr_comment;
6682         TALLOC_CTX *_mem_save_comment_0;
6683         if (ndr_flags & NDR_SCALARS) {
6684                 NDR_CHECK(ndr_pull_align(ndr, 5));
6685                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->flags));
6686                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6687                 if (_ptr_description) {
6688                         NDR_PULL_ALLOC(ndr, r->description);
6689                 } else {
6690                         r->description = NULL;
6691                 }
6692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6693                 if (_ptr_name) {
6694                         NDR_PULL_ALLOC(ndr, r->name);
6695                 } else {
6696                         r->name = NULL;
6697                 }
6698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6699                 if (_ptr_comment) {
6700                         NDR_PULL_ALLOC(ndr, r->comment);
6701                 } else {
6702                         r->comment = NULL;
6703                 }
6704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6705         }
6706         if (ndr_flags & NDR_BUFFERS) {
6707                 if (r->description) {
6708                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6709                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6710                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6711                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6712                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6713                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6714                         }
6715                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6716                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6718                 }
6719                 if (r->name) {
6720                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6721                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6722                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6723                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6724                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6725                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6726                         }
6727                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6730                 }
6731                 if (r->comment) {
6732                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6733                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6734                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6735                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6736                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6737                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6738                         }
6739                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6740                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6742                 }
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6748 {
6749         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6750         ndr->depth++;
6751         ndr_print_spoolss_PrinterAttributes(ndr, "flags", r->flags);
6752         ndr_print_ptr(ndr, "description", r->description);
6753         ndr->depth++;
6754         if (r->description) {
6755                 ndr_print_string(ndr, "description", r->description);
6756         }
6757         ndr->depth--;
6758         ndr_print_ptr(ndr, "name", r->name);
6759         ndr->depth++;
6760         if (r->name) {
6761                 ndr_print_string(ndr, "name", r->name);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "comment", r->comment);
6765         ndr->depth++;
6766         if (r->comment) {
6767                 ndr_print_string(ndr, "comment", r->comment);
6768         }
6769         ndr->depth--;
6770         ndr->depth--;
6771 }
6772
6773 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6774 {
6775         if (ndr_flags & NDR_SCALARS) {
6776                 NDR_CHECK(ndr_push_align(ndr, 5));
6777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6778                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6779                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6784                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6790                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6795                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6799         }
6800         if (ndr_flags & NDR_BUFFERS) {
6801                 if (r->servername) {
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6806                 }
6807                 if (r->printername) {
6808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6812                 }
6813                 if (r->sharename) {
6814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6815                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6817                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6818                 }
6819                 if (r->portname) {
6820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6821                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6824                 }
6825                 if (r->drivername) {
6826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6827                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6830                 }
6831                 if (r->comment) {
6832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6833                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6834                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6835                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6836                 }
6837                 if (r->location) {
6838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6839                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6840                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6841                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6842                 }
6843                 if (r->devmode) {
6844                         {
6845                                 struct ndr_push *_ndr_devmode;
6846                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6847                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6848                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6849                         }
6850                 }
6851                 if (r->sepfile) {
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6856                 }
6857                 if (r->printprocessor) {
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6862                 }
6863                 if (r->datatype) {
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6868                 }
6869                 if (r->parameters) {
6870                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6874                 }
6875                 if (r->secdesc) {
6876                         {
6877                                 struct ndr_push *_ndr_secdesc;
6878                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6879                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6880                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6881                         }
6882                 }
6883         }
6884         return NDR_ERR_SUCCESS;
6885 }
6886
6887 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6888 {
6889         uint32_t _ptr_servername;
6890         TALLOC_CTX *_mem_save_servername_0;
6891         uint32_t _ptr_printername;
6892         TALLOC_CTX *_mem_save_printername_0;
6893         uint32_t _ptr_sharename;
6894         TALLOC_CTX *_mem_save_sharename_0;
6895         uint32_t _ptr_portname;
6896         TALLOC_CTX *_mem_save_portname_0;
6897         uint32_t _ptr_drivername;
6898         TALLOC_CTX *_mem_save_drivername_0;
6899         uint32_t _ptr_comment;
6900         TALLOC_CTX *_mem_save_comment_0;
6901         uint32_t _ptr_location;
6902         TALLOC_CTX *_mem_save_location_0;
6903         uint32_t _ptr_devmode;
6904         TALLOC_CTX *_mem_save_devmode_0;
6905         uint32_t _ptr_sepfile;
6906         TALLOC_CTX *_mem_save_sepfile_0;
6907         uint32_t _ptr_printprocessor;
6908         TALLOC_CTX *_mem_save_printprocessor_0;
6909         uint32_t _ptr_datatype;
6910         TALLOC_CTX *_mem_save_datatype_0;
6911         uint32_t _ptr_parameters;
6912         TALLOC_CTX *_mem_save_parameters_0;
6913         uint32_t _ptr_secdesc;
6914         TALLOC_CTX *_mem_save_secdesc_0;
6915         if (ndr_flags & NDR_SCALARS) {
6916                 NDR_CHECK(ndr_pull_align(ndr, 5));
6917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6918                 if (_ptr_servername) {
6919                         NDR_PULL_ALLOC(ndr, r->servername);
6920                 } else {
6921                         r->servername = NULL;
6922                 }
6923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6924                 if (_ptr_printername) {
6925                         NDR_PULL_ALLOC(ndr, r->printername);
6926                 } else {
6927                         r->printername = NULL;
6928                 }
6929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6930                 if (_ptr_sharename) {
6931                         NDR_PULL_ALLOC(ndr, r->sharename);
6932                 } else {
6933                         r->sharename = NULL;
6934                 }
6935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6936                 if (_ptr_portname) {
6937                         NDR_PULL_ALLOC(ndr, r->portname);
6938                 } else {
6939                         r->portname = NULL;
6940                 }
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6942                 if (_ptr_drivername) {
6943                         NDR_PULL_ALLOC(ndr, r->drivername);
6944                 } else {
6945                         r->drivername = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6948                 if (_ptr_comment) {
6949                         NDR_PULL_ALLOC(ndr, r->comment);
6950                 } else {
6951                         r->comment = NULL;
6952                 }
6953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6954                 if (_ptr_location) {
6955                         NDR_PULL_ALLOC(ndr, r->location);
6956                 } else {
6957                         r->location = NULL;
6958                 }
6959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6960                 if (_ptr_devmode) {
6961                         NDR_PULL_ALLOC(ndr, r->devmode);
6962                 } else {
6963                         r->devmode = NULL;
6964                 }
6965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6966                 if (_ptr_sepfile) {
6967                         NDR_PULL_ALLOC(ndr, r->sepfile);
6968                 } else {
6969                         r->sepfile = NULL;
6970                 }
6971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6972                 if (_ptr_printprocessor) {
6973                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6974                 } else {
6975                         r->printprocessor = NULL;
6976                 }
6977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6978                 if (_ptr_datatype) {
6979                         NDR_PULL_ALLOC(ndr, r->datatype);
6980                 } else {
6981                         r->datatype = NULL;
6982                 }
6983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6984                 if (_ptr_parameters) {
6985                         NDR_PULL_ALLOC(ndr, r->parameters);
6986                 } else {
6987                         r->parameters = NULL;
6988                 }
6989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6990                 if (_ptr_secdesc) {
6991                         NDR_PULL_ALLOC(ndr, r->secdesc);
6992                 } else {
6993                         r->secdesc = NULL;
6994                 }
6995                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6997                 if (r->priority > 99) {
6998                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6999                 }
7000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
7001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
7002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
7003                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
7005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
7006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7007         }
7008         if (ndr_flags & NDR_BUFFERS) {
7009                 if (r->servername) {
7010                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7014                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7015                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7020                 }
7021                 if (r->printername) {
7022                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7023                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7026                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7027                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7028                         }
7029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7032                 }
7033                 if (r->sharename) {
7034                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7038                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7044                 }
7045                 if (r->portname) {
7046                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7047                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7050                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7052                         }
7053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7056                 }
7057                 if (r->drivername) {
7058                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7062                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7063                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7068                 }
7069                 if (r->comment) {
7070                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7074                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7075                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7080                 }
7081                 if (r->location) {
7082                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7086                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7087                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7092                 }
7093                 if (r->devmode) {
7094                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
7096                         {
7097                                 struct ndr_pull *_ndr_devmode;
7098                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
7099                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
7100                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
7101                         }
7102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
7103                 }
7104                 if (r->sepfile) {
7105                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7106                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7109                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7110                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
7111                         }
7112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7115                 }
7116                 if (r->printprocessor) {
7117                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7118                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7121                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7122                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
7123                         }
7124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7127                 }
7128                 if (r->datatype) {
7129                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7130                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7133                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7134                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
7135                         }
7136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7137                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7139                 }
7140                 if (r->parameters) {
7141                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7142                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7145                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7146                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
7147                         }
7148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7149                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7151                 }
7152                 if (r->secdesc) {
7153                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
7154                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
7155                         {
7156                                 struct ndr_pull *_ndr_secdesc;
7157                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
7158                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
7159                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
7160                         }
7161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
7162                 }
7163         }
7164         return NDR_ERR_SUCCESS;
7165 }
7166
7167 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7168 {
7169         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7170         ndr->depth++;
7171         ndr_print_ptr(ndr, "servername", r->servername);
7172         ndr->depth++;
7173         if (r->servername) {
7174                 ndr_print_string(ndr, "servername", r->servername);
7175         }
7176         ndr->depth--;
7177         ndr_print_ptr(ndr, "printername", r->printername);
7178         ndr->depth++;
7179         if (r->printername) {
7180                 ndr_print_string(ndr, "printername", r->printername);
7181         }
7182         ndr->depth--;
7183         ndr_print_ptr(ndr, "sharename", r->sharename);
7184         ndr->depth++;
7185         if (r->sharename) {
7186                 ndr_print_string(ndr, "sharename", r->sharename);
7187         }
7188         ndr->depth--;
7189         ndr_print_ptr(ndr, "portname", r->portname);
7190         ndr->depth++;
7191         if (r->portname) {
7192                 ndr_print_string(ndr, "portname", r->portname);
7193         }
7194         ndr->depth--;
7195         ndr_print_ptr(ndr, "drivername", r->drivername);
7196         ndr->depth++;
7197         if (r->drivername) {
7198                 ndr_print_string(ndr, "drivername", r->drivername);
7199         }
7200         ndr->depth--;
7201         ndr_print_ptr(ndr, "comment", r->comment);
7202         ndr->depth++;
7203         if (r->comment) {
7204                 ndr_print_string(ndr, "comment", r->comment);
7205         }
7206         ndr->depth--;
7207         ndr_print_ptr(ndr, "location", r->location);
7208         ndr->depth++;
7209         if (r->location) {
7210                 ndr_print_string(ndr, "location", r->location);
7211         }
7212         ndr->depth--;
7213         ndr_print_ptr(ndr, "devmode", r->devmode);
7214         ndr->depth++;
7215         if (r->devmode) {
7216                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
7217         }
7218         ndr->depth--;
7219         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7220         ndr->depth++;
7221         if (r->sepfile) {
7222                 ndr_print_string(ndr, "sepfile", r->sepfile);
7223         }
7224         ndr->depth--;
7225         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7226         ndr->depth++;
7227         if (r->printprocessor) {
7228                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7229         }
7230         ndr->depth--;
7231         ndr_print_ptr(ndr, "datatype", r->datatype);
7232         ndr->depth++;
7233         if (r->datatype) {
7234                 ndr_print_string(ndr, "datatype", r->datatype);
7235         }
7236         ndr->depth--;
7237         ndr_print_ptr(ndr, "parameters", r->parameters);
7238         ndr->depth++;
7239         if (r->parameters) {
7240                 ndr_print_string(ndr, "parameters", r->parameters);
7241         }
7242         ndr->depth--;
7243         ndr_print_ptr(ndr, "secdesc", r->secdesc);
7244         ndr->depth++;
7245         if (r->secdesc) {
7246                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
7247         }
7248         ndr->depth--;
7249         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7250         ndr_print_uint32(ndr, "priority", r->priority);
7251         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7252         ndr_print_uint32(ndr, "starttime", r->starttime);
7253         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7254         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7255         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7256         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7257         ndr->depth--;
7258 }
7259
7260 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7261 {
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_push_align(ndr, 4));
7264                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7265                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268         }
7269         return NDR_ERR_SUCCESS;
7270 }
7271
7272 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7273 {
7274         if (ndr_flags & NDR_SCALARS) {
7275                 NDR_CHECK(ndr_pull_align(ndr, 4));
7276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280         }
7281         return NDR_ERR_SUCCESS;
7282 }
7283
7284 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7285 {
7286         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7287         ndr->depth++;
7288         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7289         ndr->depth--;
7290 }
7291
7292 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7293 {
7294         if (ndr_flags & NDR_SCALARS) {
7295                 NDR_CHECK(ndr_push_align(ndr, 5));
7296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7298                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7299                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7300         }
7301         if (ndr_flags & NDR_BUFFERS) {
7302                 if (r->printername) {
7303                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7306                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7307                 }
7308                 if (r->servername) {
7309                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7310                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7311                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7312                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7313                 }
7314         }
7315         return NDR_ERR_SUCCESS;
7316 }
7317
7318 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7319 {
7320         uint32_t _ptr_printername;
7321         TALLOC_CTX *_mem_save_printername_0;
7322         uint32_t _ptr_servername;
7323         TALLOC_CTX *_mem_save_servername_0;
7324         if (ndr_flags & NDR_SCALARS) {
7325                 NDR_CHECK(ndr_pull_align(ndr, 5));
7326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7327                 if (_ptr_printername) {
7328                         NDR_PULL_ALLOC(ndr, r->printername);
7329                 } else {
7330                         r->printername = NULL;
7331                 }
7332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7333                 if (_ptr_servername) {
7334                         NDR_PULL_ALLOC(ndr, r->servername);
7335                 } else {
7336                         r->servername = NULL;
7337                 }
7338                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7339                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 if (r->printername) {
7343                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7344                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7345                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7346                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7347                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7348                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7349                         }
7350                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7351                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7352                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7353                 }
7354                 if (r->servername) {
7355                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7356                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7359                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7360                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
7361                         }
7362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7363                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7365                 }
7366         }
7367         return NDR_ERR_SUCCESS;
7368 }
7369
7370 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7371 {
7372         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7373         ndr->depth++;
7374         ndr_print_ptr(ndr, "printername", r->printername);
7375         ndr->depth++;
7376         if (r->printername) {
7377                 ndr_print_string(ndr, "printername", r->printername);
7378         }
7379         ndr->depth--;
7380         ndr_print_ptr(ndr, "servername", r->servername);
7381         ndr->depth++;
7382         if (r->servername) {
7383                 ndr_print_string(ndr, "servername", r->servername);
7384         }
7385         ndr->depth--;
7386         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7387         ndr->depth--;
7388 }
7389
7390 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7391 {
7392         if (ndr_flags & NDR_SCALARS) {
7393                 NDR_CHECK(ndr_push_align(ndr, 5));
7394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7396                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7399                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7400         }
7401         if (ndr_flags & NDR_BUFFERS) {
7402                 if (r->printername) {
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7407                 }
7408                 if (r->portname) {
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7413                 }
7414         }
7415         return NDR_ERR_SUCCESS;
7416 }
7417
7418 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7419 {
7420         uint32_t _ptr_printername;
7421         TALLOC_CTX *_mem_save_printername_0;
7422         uint32_t _ptr_portname;
7423         TALLOC_CTX *_mem_save_portname_0;
7424         if (ndr_flags & NDR_SCALARS) {
7425                 NDR_CHECK(ndr_pull_align(ndr, 5));
7426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7427                 if (_ptr_printername) {
7428                         NDR_PULL_ALLOC(ndr, r->printername);
7429                 } else {
7430                         r->printername = NULL;
7431                 }
7432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7433                 if (_ptr_portname) {
7434                         NDR_PULL_ALLOC(ndr, r->portname);
7435                 } else {
7436                         r->portname = NULL;
7437                 }
7438                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7442         }
7443         if (ndr_flags & NDR_BUFFERS) {
7444                 if (r->printername) {
7445                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7446                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7448                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7449                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7450                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
7451                         }
7452                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7453                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7455                 }
7456                 if (r->portname) {
7457                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7458                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7459                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7460                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7461                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7462                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
7463                         }
7464                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7465                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7467                 }
7468         }
7469         return NDR_ERR_SUCCESS;
7470 }
7471
7472 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7473 {
7474         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7475         ndr->depth++;
7476         ndr_print_ptr(ndr, "printername", r->printername);
7477         ndr->depth++;
7478         if (r->printername) {
7479                 ndr_print_string(ndr, "printername", r->printername);
7480         }
7481         ndr->depth--;
7482         ndr_print_ptr(ndr, "portname", r->portname);
7483         ndr->depth++;
7484         if (r->portname) {
7485                 ndr_print_string(ndr, "portname", r->portname);
7486         }
7487         ndr->depth--;
7488         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7489         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7490         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7491         ndr->depth--;
7492 }
7493
7494 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7495 {
7496         if (ndr_flags & NDR_SCALARS) {
7497                 NDR_CHECK(ndr_push_align(ndr, 4));
7498                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7499                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7500         }
7501         if (ndr_flags & NDR_BUFFERS) {
7502         }
7503         return NDR_ERR_SUCCESS;
7504 }
7505
7506 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7507 {
7508         if (ndr_flags & NDR_SCALARS) {
7509                 NDR_CHECK(ndr_pull_align(ndr, 4));
7510                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7512         }
7513         if (ndr_flags & NDR_BUFFERS) {
7514         }
7515         return NDR_ERR_SUCCESS;
7516 }
7517
7518 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7519 {
7520         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7521         ndr->depth++;
7522         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7523         ndr->depth--;
7524 }
7525
7526 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7527 {
7528         if (ndr_flags & NDR_SCALARS) {
7529                 NDR_CHECK(ndr_push_align(ndr, 5));
7530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7531                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7532                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->guid) {
7536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7546 {
7547         uint32_t _ptr_guid;
7548         TALLOC_CTX *_mem_save_guid_0;
7549         if (ndr_flags & NDR_SCALARS) {
7550                 NDR_CHECK(ndr_pull_align(ndr, 5));
7551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7552                 if (_ptr_guid) {
7553                         NDR_PULL_ALLOC(ndr, r->guid);
7554                 } else {
7555                         r->guid = NULL;
7556                 }
7557                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7558                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7559         }
7560         if (ndr_flags & NDR_BUFFERS) {
7561                 if (r->guid) {
7562                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7563                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7566                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7567                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
7568                         }
7569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7570                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7572                 }
7573         }
7574         return NDR_ERR_SUCCESS;
7575 }
7576
7577 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7578 {
7579         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7580         ndr->depth++;
7581         ndr_print_ptr(ndr, "guid", r->guid);
7582         ndr->depth++;
7583         if (r->guid) {
7584                 ndr_print_string(ndr, "guid", r->guid);
7585         }
7586         ndr->depth--;
7587         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7588         ndr->depth--;
7589 }
7590
7591 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7592 {
7593         if (ndr_flags & NDR_SCALARS) {
7594                 int level = ndr_push_get_switch_value(ndr, r);
7595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7596                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7597                 switch (level) {
7598                         case 0: {
7599                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7600                         break; }
7601
7602                         case 1: {
7603                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7604                         break; }
7605
7606                         case 2: {
7607                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7608                         break; }
7609
7610                         case 3: {
7611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7612                         break; }
7613
7614                         case 4: {
7615                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7616                         break; }
7617
7618                         case 5: {
7619                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7620                         break; }
7621
7622                         case 6: {
7623                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7624                         break; }
7625
7626                         case 7: {
7627                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7628                         break; }
7629
7630                         case 8: {
7631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7632                         break; }
7633
7634                         case 9: {
7635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7636                         break; }
7637
7638                         default: {
7639                         break; }
7640
7641                 }
7642         }
7643         if (ndr_flags & NDR_BUFFERS) {
7644                 int level = ndr_push_get_switch_value(ndr, r);
7645                 switch (level) {
7646                         case 0:
7647                                 if (r->info0) {
7648                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7649                                 }
7650                         break;
7651
7652                         case 1:
7653                                 if (r->info1) {
7654                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7655                                 }
7656                         break;
7657
7658                         case 2:
7659                                 if (r->info2) {
7660                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7661                                 }
7662                         break;
7663
7664                         case 3:
7665                                 if (r->info3) {
7666                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7667                                 }
7668                         break;
7669
7670                         case 4:
7671                                 if (r->info4) {
7672                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7673                                 }
7674                         break;
7675
7676                         case 5:
7677                                 if (r->info5) {
7678                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7679                                 }
7680                         break;
7681
7682                         case 6:
7683                                 if (r->info6) {
7684                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7685                                 }
7686                         break;
7687
7688                         case 7:
7689                                 if (r->info7) {
7690                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7691                                 }
7692                         break;
7693
7694                         case 8:
7695                                 if (r->info8) {
7696                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7697                                 }
7698                         break;
7699
7700                         case 9:
7701                                 if (r->info9) {
7702                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7703                                 }
7704                         break;
7705
7706                         default:
7707                         break;
7708
7709                 }
7710         }
7711         return NDR_ERR_SUCCESS;
7712 }
7713
7714 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7715 {
7716         int level;
7717         uint32_t _level;
7718         TALLOC_CTX *_mem_save_info0_0;
7719         TALLOC_CTX *_mem_save_info1_0;
7720         TALLOC_CTX *_mem_save_info2_0;
7721         TALLOC_CTX *_mem_save_info3_0;
7722         TALLOC_CTX *_mem_save_info4_0;
7723         TALLOC_CTX *_mem_save_info5_0;
7724         TALLOC_CTX *_mem_save_info6_0;
7725         TALLOC_CTX *_mem_save_info7_0;
7726         TALLOC_CTX *_mem_save_info8_0;
7727         TALLOC_CTX *_mem_save_info9_0;
7728         level = ndr_pull_get_switch_value(ndr, r);
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7731                 if (_level != level) {
7732                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7733                 }
7734                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7735                 switch (level) {
7736                         case 0: {
7737                                 uint32_t _ptr_info0;
7738                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7739                                 if (_ptr_info0) {
7740                                         NDR_PULL_ALLOC(ndr, r->info0);
7741                                 } else {
7742                                         r->info0 = NULL;
7743                                 }
7744                         break; }
7745
7746                         case 1: {
7747                                 uint32_t _ptr_info1;
7748                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7749                                 if (_ptr_info1) {
7750                                         NDR_PULL_ALLOC(ndr, r->info1);
7751                                 } else {
7752                                         r->info1 = NULL;
7753                                 }
7754                         break; }
7755
7756                         case 2: {
7757                                 uint32_t _ptr_info2;
7758                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7759                                 if (_ptr_info2) {
7760                                         NDR_PULL_ALLOC(ndr, r->info2);
7761                                 } else {
7762                                         r->info2 = NULL;
7763                                 }
7764                         break; }
7765
7766                         case 3: {
7767                                 uint32_t _ptr_info3;
7768                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7769                                 if (_ptr_info3) {
7770                                         NDR_PULL_ALLOC(ndr, r->info3);
7771                                 } else {
7772                                         r->info3 = NULL;
7773                                 }
7774                         break; }
7775
7776                         case 4: {
7777                                 uint32_t _ptr_info4;
7778                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7779                                 if (_ptr_info4) {
7780                                         NDR_PULL_ALLOC(ndr, r->info4);
7781                                 } else {
7782                                         r->info4 = NULL;
7783                                 }
7784                         break; }
7785
7786                         case 5: {
7787                                 uint32_t _ptr_info5;
7788                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7789                                 if (_ptr_info5) {
7790                                         NDR_PULL_ALLOC(ndr, r->info5);
7791                                 } else {
7792                                         r->info5 = NULL;
7793                                 }
7794                         break; }
7795
7796                         case 6: {
7797                                 uint32_t _ptr_info6;
7798                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7799                                 if (_ptr_info6) {
7800                                         NDR_PULL_ALLOC(ndr, r->info6);
7801                                 } else {
7802                                         r->info6 = NULL;
7803                                 }
7804                         break; }
7805
7806                         case 7: {
7807                                 uint32_t _ptr_info7;
7808                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7809                                 if (_ptr_info7) {
7810                                         NDR_PULL_ALLOC(ndr, r->info7);
7811                                 } else {
7812                                         r->info7 = NULL;
7813                                 }
7814                         break; }
7815
7816                         case 8: {
7817                                 uint32_t _ptr_info8;
7818                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7819                                 if (_ptr_info8) {
7820                                         NDR_PULL_ALLOC(ndr, r->info8);
7821                                 } else {
7822                                         r->info8 = NULL;
7823                                 }
7824                         break; }
7825
7826                         case 9: {
7827                                 uint32_t _ptr_info9;
7828                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7829                                 if (_ptr_info9) {
7830                                         NDR_PULL_ALLOC(ndr, r->info9);
7831                                 } else {
7832                                         r->info9 = NULL;
7833                                 }
7834                         break; }
7835
7836                         default: {
7837                         break; }
7838
7839                 }
7840         }
7841         if (ndr_flags & NDR_BUFFERS) {
7842                 switch (level) {
7843                         case 0:
7844                                 if (r->info0) {
7845                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7846                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7847                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7848                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7849                                 }
7850                         break;
7851
7852                         case 1:
7853                                 if (r->info1) {
7854                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7855                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7856                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7857                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7858                                 }
7859                         break;
7860
7861                         case 2:
7862                                 if (r->info2) {
7863                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7865                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7866                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7867                                 }
7868                         break;
7869
7870                         case 3:
7871                                 if (r->info3) {
7872                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7873                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7874                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7875                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7876                                 }
7877                         break;
7878
7879                         case 4:
7880                                 if (r->info4) {
7881                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7882                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7883                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7884                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7885                                 }
7886                         break;
7887
7888                         case 5:
7889                                 if (r->info5) {
7890                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7891                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7892                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7893                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7894                                 }
7895                         break;
7896
7897                         case 6:
7898                                 if (r->info6) {
7899                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7901                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7902                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7903                                 }
7904                         break;
7905
7906                         case 7:
7907                                 if (r->info7) {
7908                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7909                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7910                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7911                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7912                                 }
7913                         break;
7914
7915                         case 8:
7916                                 if (r->info8) {
7917                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7918                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7919                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7920                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7921                                 }
7922                         break;
7923
7924                         case 9:
7925                                 if (r->info9) {
7926                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7927                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7928                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7929                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7930                                 }
7931                         break;
7932
7933                         default:
7934                         break;
7935
7936                 }
7937         }
7938         return NDR_ERR_SUCCESS;
7939 }
7940
7941 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7942 {
7943         int level;
7944         level = ndr_print_get_switch_value(ndr, r);
7945         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7946         switch (level) {
7947                 case 0:
7948                         ndr_print_ptr(ndr, "info0", r->info0);
7949                         ndr->depth++;
7950                         if (r->info0) {
7951                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7952                         }
7953                         ndr->depth--;
7954                 break;
7955
7956                 case 1:
7957                         ndr_print_ptr(ndr, "info1", r->info1);
7958                         ndr->depth++;
7959                         if (r->info1) {
7960                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7961                         }
7962                         ndr->depth--;
7963                 break;
7964
7965                 case 2:
7966                         ndr_print_ptr(ndr, "info2", r->info2);
7967                         ndr->depth++;
7968                         if (r->info2) {
7969                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7970                         }
7971                         ndr->depth--;
7972                 break;
7973
7974                 case 3:
7975                         ndr_print_ptr(ndr, "info3", r->info3);
7976                         ndr->depth++;
7977                         if (r->info3) {
7978                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7979                         }
7980                         ndr->depth--;
7981                 break;
7982
7983                 case 4:
7984                         ndr_print_ptr(ndr, "info4", r->info4);
7985                         ndr->depth++;
7986                         if (r->info4) {
7987                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7988                         }
7989                         ndr->depth--;
7990                 break;
7991
7992                 case 5:
7993                         ndr_print_ptr(ndr, "info5", r->info5);
7994                         ndr->depth++;
7995                         if (r->info5) {
7996                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7997                         }
7998                         ndr->depth--;
7999                 break;
8000
8001                 case 6:
8002                         ndr_print_ptr(ndr, "info6", r->info6);
8003                         ndr->depth++;
8004                         if (r->info6) {
8005                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8006                         }
8007                         ndr->depth--;
8008                 break;
8009
8010                 case 7:
8011                         ndr_print_ptr(ndr, "info7", r->info7);
8012                         ndr->depth++;
8013                         if (r->info7) {
8014                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8015                         }
8016                         ndr->depth--;
8017                 break;
8018
8019                 case 8:
8020                         ndr_print_ptr(ndr, "info8", r->info8);
8021                         ndr->depth++;
8022                         if (r->info8) {
8023                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
8024                         }
8025                         ndr->depth--;
8026                 break;
8027
8028                 case 9:
8029                         ndr_print_ptr(ndr, "info9", r->info9);
8030                         ndr->depth++;
8031                         if (r->info9) {
8032                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
8033                         }
8034                         ndr->depth--;
8035                 break;
8036
8037                 default:
8038                 break;
8039
8040         }
8041 }
8042
8043 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8044 {
8045         if (ndr_flags & NDR_SCALARS) {
8046                 NDR_CHECK(ndr_push_align(ndr, 5));
8047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8048                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8049                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8050                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8051         }
8052         if (ndr_flags & NDR_BUFFERS) {
8053                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8054         }
8055         return NDR_ERR_SUCCESS;
8056 }
8057
8058 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8059 {
8060         if (ndr_flags & NDR_SCALARS) {
8061                 NDR_CHECK(ndr_pull_align(ndr, 5));
8062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8063                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8064                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8065                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8066         }
8067         if (ndr_flags & NDR_BUFFERS) {
8068                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8069         }
8070         return NDR_ERR_SUCCESS;
8071 }
8072
8073 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8074 {
8075         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8076         ndr->depth++;
8077         ndr_print_uint32(ndr, "level", r->level);
8078         ndr_print_set_switch_value(ndr, &r->info, r->level);
8079         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8080         ndr->depth--;
8081 }
8082
8083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8084 {
8085         if (ndr_flags & NDR_SCALARS) {
8086                 NDR_CHECK(ndr_push_align(ndr, 4));
8087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8088                 {
8089                         uint32_t _flags_save_string_array = ndr->flags;
8090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8091                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8092                         ndr->flags = _flags_save_string_array;
8093                 }
8094                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8095         }
8096         if (ndr_flags & NDR_BUFFERS) {
8097         }
8098         return NDR_ERR_SUCCESS;
8099 }
8100
8101 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8102 {
8103         if (ndr_flags & NDR_SCALARS) {
8104                 NDR_CHECK(ndr_pull_align(ndr, 4));
8105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8106                 {
8107                         uint32_t _flags_save_string_array = ndr->flags;
8108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8109                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8110                         ndr->flags = _flags_save_string_array;
8111                 }
8112                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8113         }
8114         if (ndr_flags & NDR_BUFFERS) {
8115         }
8116         return NDR_ERR_SUCCESS;
8117 }
8118
8119 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8120 {
8121         ndr_print_struct(ndr, name, "spoolss_StringArray");
8122         ndr->depth++;
8123         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
8124         ndr_print_string_array(ndr, "string", r->string);
8125         ndr->depth--;
8126 }
8127
8128 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8129 {
8130         if (ndr_flags & NDR_SCALARS) {
8131                 NDR_CHECK(ndr_push_align(ndr, 5));
8132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8133                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8134         }
8135         if (ndr_flags & NDR_BUFFERS) {
8136                 if (r->driver_name) {
8137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8140                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8141                 }
8142         }
8143         return NDR_ERR_SUCCESS;
8144 }
8145
8146 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8147 {
8148         uint32_t _ptr_driver_name;
8149         TALLOC_CTX *_mem_save_driver_name_0;
8150         if (ndr_flags & NDR_SCALARS) {
8151                 NDR_CHECK(ndr_pull_align(ndr, 5));
8152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8153                 if (_ptr_driver_name) {
8154                         NDR_PULL_ALLOC(ndr, r->driver_name);
8155                 } else {
8156                         r->driver_name = NULL;
8157                 }
8158                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8159         }
8160         if (ndr_flags & NDR_BUFFERS) {
8161                 if (r->driver_name) {
8162                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8163                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8166                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8167                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8168                         }
8169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8172                 }
8173         }
8174         return NDR_ERR_SUCCESS;
8175 }
8176
8177 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8178 {
8179         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8180         ndr->depth++;
8181         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8182         ndr->depth++;
8183         if (r->driver_name) {
8184                 ndr_print_string(ndr, "driver_name", r->driver_name);
8185         }
8186         ndr->depth--;
8187         ndr->depth--;
8188 }
8189
8190 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8191 {
8192         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8193         return NDR_ERR_SUCCESS;
8194 }
8195
8196 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8197 {
8198         uint32_t v;
8199         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8200         *r = v;
8201         return NDR_ERR_SUCCESS;
8202 }
8203
8204 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8205 {
8206         const char *val = NULL;
8207
8208         switch (r) {
8209                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8210                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8211                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8212                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8213         }
8214         ndr_print_enum(ndr, name, "ENUM", val, r);
8215 }
8216
8217 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8218 {
8219         if (ndr_flags & NDR_SCALARS) {
8220                 NDR_CHECK(ndr_push_align(ndr, 5));
8221                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8224                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8227                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8228         }
8229         if (ndr_flags & NDR_BUFFERS) {
8230                 if (r->driver_name) {
8231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8235                 }
8236                 if (r->architecture) {
8237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8240                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8241                 }
8242                 if (r->driver_path) {
8243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8244                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8247                 }
8248                 if (r->data_file) {
8249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8253                 }
8254                 if (r->config_file) {
8255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8259                 }
8260         }
8261         return NDR_ERR_SUCCESS;
8262 }
8263
8264 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8265 {
8266         uint32_t _ptr_driver_name;
8267         TALLOC_CTX *_mem_save_driver_name_0;
8268         uint32_t _ptr_architecture;
8269         TALLOC_CTX *_mem_save_architecture_0;
8270         uint32_t _ptr_driver_path;
8271         TALLOC_CTX *_mem_save_driver_path_0;
8272         uint32_t _ptr_data_file;
8273         TALLOC_CTX *_mem_save_data_file_0;
8274         uint32_t _ptr_config_file;
8275         TALLOC_CTX *_mem_save_config_file_0;
8276         if (ndr_flags & NDR_SCALARS) {
8277                 NDR_CHECK(ndr_pull_align(ndr, 5));
8278                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8280                 if (_ptr_driver_name) {
8281                         NDR_PULL_ALLOC(ndr, r->driver_name);
8282                 } else {
8283                         r->driver_name = NULL;
8284                 }
8285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8286                 if (_ptr_architecture) {
8287                         NDR_PULL_ALLOC(ndr, r->architecture);
8288                 } else {
8289                         r->architecture = NULL;
8290                 }
8291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8292                 if (_ptr_driver_path) {
8293                         NDR_PULL_ALLOC(ndr, r->driver_path);
8294                 } else {
8295                         r->driver_path = NULL;
8296                 }
8297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8298                 if (_ptr_data_file) {
8299                         NDR_PULL_ALLOC(ndr, r->data_file);
8300                 } else {
8301                         r->data_file = NULL;
8302                 }
8303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8304                 if (_ptr_config_file) {
8305                         NDR_PULL_ALLOC(ndr, r->config_file);
8306                 } else {
8307                         r->config_file = NULL;
8308                 }
8309                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8310         }
8311         if (ndr_flags & NDR_BUFFERS) {
8312                 if (r->driver_name) {
8313                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8314                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8317                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8318                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8319                         }
8320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8323                 }
8324                 if (r->architecture) {
8325                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8326                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8329                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8330                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8331                         }
8332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8335                 }
8336                 if (r->driver_path) {
8337                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8338                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8339                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8340                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8341                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8342                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8343                         }
8344                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8345                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8347                 }
8348                 if (r->data_file) {
8349                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8350                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8353                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8354                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8355                         }
8356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8359                 }
8360                 if (r->config_file) {
8361                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8362                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8365                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8366                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8367                         }
8368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8369                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8371                 }
8372         }
8373         return NDR_ERR_SUCCESS;
8374 }
8375
8376 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8377 {
8378         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8379         ndr->depth++;
8380         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8381         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8382         ndr->depth++;
8383         if (r->driver_name) {
8384                 ndr_print_string(ndr, "driver_name", r->driver_name);
8385         }
8386         ndr->depth--;
8387         ndr_print_ptr(ndr, "architecture", r->architecture);
8388         ndr->depth++;
8389         if (r->architecture) {
8390                 ndr_print_string(ndr, "architecture", r->architecture);
8391         }
8392         ndr->depth--;
8393         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8394         ndr->depth++;
8395         if (r->driver_path) {
8396                 ndr_print_string(ndr, "driver_path", r->driver_path);
8397         }
8398         ndr->depth--;
8399         ndr_print_ptr(ndr, "data_file", r->data_file);
8400         ndr->depth++;
8401         if (r->data_file) {
8402                 ndr_print_string(ndr, "data_file", r->data_file);
8403         }
8404         ndr->depth--;
8405         ndr_print_ptr(ndr, "config_file", r->config_file);
8406         ndr->depth++;
8407         if (r->config_file) {
8408                 ndr_print_string(ndr, "config_file", r->config_file);
8409         }
8410         ndr->depth--;
8411         ndr->depth--;
8412 }
8413
8414 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8415 {
8416         if (ndr_flags & NDR_SCALARS) {
8417                 NDR_CHECK(ndr_push_align(ndr, 5));
8418                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8429                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8430         }
8431         if (ndr_flags & NDR_BUFFERS) {
8432                 if (r->driver_name) {
8433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8437                 }
8438                 if (r->architecture) {
8439                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8443                 }
8444                 if (r->driver_path) {
8445                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8449                 }
8450                 if (r->data_file) {
8451                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8452                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8455                 }
8456                 if (r->config_file) {
8457                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8458                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8461                 }
8462                 if (r->help_file) {
8463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8467                 }
8468                 if (r->monitor_name) {
8469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8473                 }
8474                 if (r->default_datatype) {
8475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8479                 }
8480                 if (r->dependent_files) {
8481                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8482                 }
8483         }
8484         return NDR_ERR_SUCCESS;
8485 }
8486
8487 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8488 {
8489         uint32_t _ptr_driver_name;
8490         TALLOC_CTX *_mem_save_driver_name_0;
8491         uint32_t _ptr_architecture;
8492         TALLOC_CTX *_mem_save_architecture_0;
8493         uint32_t _ptr_driver_path;
8494         TALLOC_CTX *_mem_save_driver_path_0;
8495         uint32_t _ptr_data_file;
8496         TALLOC_CTX *_mem_save_data_file_0;
8497         uint32_t _ptr_config_file;
8498         TALLOC_CTX *_mem_save_config_file_0;
8499         uint32_t _ptr_help_file;
8500         TALLOC_CTX *_mem_save_help_file_0;
8501         uint32_t _ptr_monitor_name;
8502         TALLOC_CTX *_mem_save_monitor_name_0;
8503         uint32_t _ptr_default_datatype;
8504         TALLOC_CTX *_mem_save_default_datatype_0;
8505         uint32_t _ptr_dependent_files;
8506         TALLOC_CTX *_mem_save_dependent_files_0;
8507         if (ndr_flags & NDR_SCALARS) {
8508                 NDR_CHECK(ndr_pull_align(ndr, 5));
8509                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8511                 if (_ptr_driver_name) {
8512                         NDR_PULL_ALLOC(ndr, r->driver_name);
8513                 } else {
8514                         r->driver_name = NULL;
8515                 }
8516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8517                 if (_ptr_architecture) {
8518                         NDR_PULL_ALLOC(ndr, r->architecture);
8519                 } else {
8520                         r->architecture = NULL;
8521                 }
8522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8523                 if (_ptr_driver_path) {
8524                         NDR_PULL_ALLOC(ndr, r->driver_path);
8525                 } else {
8526                         r->driver_path = NULL;
8527                 }
8528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8529                 if (_ptr_data_file) {
8530                         NDR_PULL_ALLOC(ndr, r->data_file);
8531                 } else {
8532                         r->data_file = NULL;
8533                 }
8534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8535                 if (_ptr_config_file) {
8536                         NDR_PULL_ALLOC(ndr, r->config_file);
8537                 } else {
8538                         r->config_file = NULL;
8539                 }
8540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8541                 if (_ptr_help_file) {
8542                         NDR_PULL_ALLOC(ndr, r->help_file);
8543                 } else {
8544                         r->help_file = NULL;
8545                 }
8546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8547                 if (_ptr_monitor_name) {
8548                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8549                 } else {
8550                         r->monitor_name = NULL;
8551                 }
8552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8553                 if (_ptr_default_datatype) {
8554                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8555                 } else {
8556                         r->default_datatype = NULL;
8557                 }
8558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8560                 if (_ptr_dependent_files) {
8561                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8562                 } else {
8563                         r->dependent_files = NULL;
8564                 }
8565                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8566         }
8567         if (ndr_flags & NDR_BUFFERS) {
8568                 if (r->driver_name) {
8569                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8570                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8573                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8574                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8575                         }
8576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8579                 }
8580                 if (r->architecture) {
8581                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8582                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8585                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8586                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8587                         }
8588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8591                 }
8592                 if (r->driver_path) {
8593                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8594                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8597                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8598                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8599                         }
8600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8603                 }
8604                 if (r->data_file) {
8605                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8606                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8609                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8611                         }
8612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8615                 }
8616                 if (r->config_file) {
8617                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8618                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8621                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8623                         }
8624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8627                 }
8628                 if (r->help_file) {
8629                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8630                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8633                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8634                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8635                         }
8636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8639                 }
8640                 if (r->monitor_name) {
8641                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8642                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8645                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8646                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8647                         }
8648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8651                 }
8652                 if (r->default_datatype) {
8653                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8654                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8657                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8658                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8659                         }
8660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8663                 }
8664                 if (r->dependent_files) {
8665                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8666                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8667                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8669                 }
8670         }
8671         return NDR_ERR_SUCCESS;
8672 }
8673
8674 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8675 {
8676         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8677         ndr->depth++;
8678         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8679         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8680         ndr->depth++;
8681         if (r->driver_name) {
8682                 ndr_print_string(ndr, "driver_name", r->driver_name);
8683         }
8684         ndr->depth--;
8685         ndr_print_ptr(ndr, "architecture", r->architecture);
8686         ndr->depth++;
8687         if (r->architecture) {
8688                 ndr_print_string(ndr, "architecture", r->architecture);
8689         }
8690         ndr->depth--;
8691         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8692         ndr->depth++;
8693         if (r->driver_path) {
8694                 ndr_print_string(ndr, "driver_path", r->driver_path);
8695         }
8696         ndr->depth--;
8697         ndr_print_ptr(ndr, "data_file", r->data_file);
8698         ndr->depth++;
8699         if (r->data_file) {
8700                 ndr_print_string(ndr, "data_file", r->data_file);
8701         }
8702         ndr->depth--;
8703         ndr_print_ptr(ndr, "config_file", r->config_file);
8704         ndr->depth++;
8705         if (r->config_file) {
8706                 ndr_print_string(ndr, "config_file", r->config_file);
8707         }
8708         ndr->depth--;
8709         ndr_print_ptr(ndr, "help_file", r->help_file);
8710         ndr->depth++;
8711         if (r->help_file) {
8712                 ndr_print_string(ndr, "help_file", r->help_file);
8713         }
8714         ndr->depth--;
8715         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8716         ndr->depth++;
8717         if (r->monitor_name) {
8718                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8719         }
8720         ndr->depth--;
8721         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8722         ndr->depth++;
8723         if (r->default_datatype) {
8724                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8725         }
8726         ndr->depth--;
8727         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8728         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8729         ndr->depth++;
8730         if (r->dependent_files) {
8731                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8732         }
8733         ndr->depth--;
8734         ndr->depth--;
8735 }
8736
8737 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8738 {
8739         if (ndr_flags & NDR_SCALARS) {
8740                 NDR_CHECK(ndr_push_align(ndr, 5));
8741                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8754                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8755         }
8756         if (ndr_flags & NDR_BUFFERS) {
8757                 if (r->driver_name) {
8758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8762                 }
8763                 if (r->architecture) {
8764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8768                 }
8769                 if (r->driver_path) {
8770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8774                 }
8775                 if (r->data_file) {
8776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8780                 }
8781                 if (r->config_file) {
8782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8786                 }
8787                 if (r->help_file) {
8788                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8789                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8791                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8792                 }
8793                 if (r->monitor_name) {
8794                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8795                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8797                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8798                 }
8799                 if (r->default_datatype) {
8800                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8803                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8804                 }
8805                 if (r->dependent_files) {
8806                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8807                 }
8808                 if (r->previous_names) {
8809                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8810                 }
8811         }
8812         return NDR_ERR_SUCCESS;
8813 }
8814
8815 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8816 {
8817         uint32_t _ptr_driver_name;
8818         TALLOC_CTX *_mem_save_driver_name_0;
8819         uint32_t _ptr_architecture;
8820         TALLOC_CTX *_mem_save_architecture_0;
8821         uint32_t _ptr_driver_path;
8822         TALLOC_CTX *_mem_save_driver_path_0;
8823         uint32_t _ptr_data_file;
8824         TALLOC_CTX *_mem_save_data_file_0;
8825         uint32_t _ptr_config_file;
8826         TALLOC_CTX *_mem_save_config_file_0;
8827         uint32_t _ptr_help_file;
8828         TALLOC_CTX *_mem_save_help_file_0;
8829         uint32_t _ptr_monitor_name;
8830         TALLOC_CTX *_mem_save_monitor_name_0;
8831         uint32_t _ptr_default_datatype;
8832         TALLOC_CTX *_mem_save_default_datatype_0;
8833         uint32_t _ptr_dependent_files;
8834         TALLOC_CTX *_mem_save_dependent_files_0;
8835         uint32_t _ptr_previous_names;
8836         TALLOC_CTX *_mem_save_previous_names_0;
8837         if (ndr_flags & NDR_SCALARS) {
8838                 NDR_CHECK(ndr_pull_align(ndr, 5));
8839                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8841                 if (_ptr_driver_name) {
8842                         NDR_PULL_ALLOC(ndr, r->driver_name);
8843                 } else {
8844                         r->driver_name = NULL;
8845                 }
8846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8847                 if (_ptr_architecture) {
8848                         NDR_PULL_ALLOC(ndr, r->architecture);
8849                 } else {
8850                         r->architecture = NULL;
8851                 }
8852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8853                 if (_ptr_driver_path) {
8854                         NDR_PULL_ALLOC(ndr, r->driver_path);
8855                 } else {
8856                         r->driver_path = NULL;
8857                 }
8858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8859                 if (_ptr_data_file) {
8860                         NDR_PULL_ALLOC(ndr, r->data_file);
8861                 } else {
8862                         r->data_file = NULL;
8863                 }
8864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8865                 if (_ptr_config_file) {
8866                         NDR_PULL_ALLOC(ndr, r->config_file);
8867                 } else {
8868                         r->config_file = NULL;
8869                 }
8870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8871                 if (_ptr_help_file) {
8872                         NDR_PULL_ALLOC(ndr, r->help_file);
8873                 } else {
8874                         r->help_file = NULL;
8875                 }
8876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8877                 if (_ptr_monitor_name) {
8878                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8879                 } else {
8880                         r->monitor_name = NULL;
8881                 }
8882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8883                 if (_ptr_default_datatype) {
8884                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8885                 } else {
8886                         r->default_datatype = NULL;
8887                 }
8888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8890                 if (_ptr_dependent_files) {
8891                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8892                 } else {
8893                         r->dependent_files = NULL;
8894                 }
8895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8897                 if (_ptr_previous_names) {
8898                         NDR_PULL_ALLOC(ndr, r->previous_names);
8899                 } else {
8900                         r->previous_names = NULL;
8901                 }
8902                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8903         }
8904         if (ndr_flags & NDR_BUFFERS) {
8905                 if (r->driver_name) {
8906                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8907                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8908                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8909                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8910                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8911                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8912                         }
8913                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8914                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8916                 }
8917                 if (r->architecture) {
8918                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8919                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8922                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8923                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8924                         }
8925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8928                 }
8929                 if (r->driver_path) {
8930                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8931                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8933                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8934                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8935                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8936                         }
8937                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8938                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8940                 }
8941                 if (r->data_file) {
8942                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8943                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8944                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8945                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8946                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8947                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8948                         }
8949                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8950                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8952                 }
8953                 if (r->config_file) {
8954                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8955                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8958                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8959                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8960                         }
8961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8964                 }
8965                 if (r->help_file) {
8966                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8967                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8970                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8971                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8972                         }
8973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8976                 }
8977                 if (r->monitor_name) {
8978                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8979                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8980                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8981                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8982                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8983                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8984                         }
8985                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8986                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8987                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8988                 }
8989                 if (r->default_datatype) {
8990                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8991                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8992                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8993                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8994                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8995                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8996                         }
8997                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8998                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9000                 }
9001                 if (r->dependent_files) {
9002                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9003                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9004                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9006                 }
9007                 if (r->previous_names) {
9008                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9009                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9010                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9012                 }
9013         }
9014         return NDR_ERR_SUCCESS;
9015 }
9016
9017 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9018 {
9019         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9020         ndr->depth++;
9021         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9022         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9023         ndr->depth++;
9024         if (r->driver_name) {
9025                 ndr_print_string(ndr, "driver_name", r->driver_name);
9026         }
9027         ndr->depth--;
9028         ndr_print_ptr(ndr, "architecture", r->architecture);
9029         ndr->depth++;
9030         if (r->architecture) {
9031                 ndr_print_string(ndr, "architecture", r->architecture);
9032         }
9033         ndr->depth--;
9034         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9035         ndr->depth++;
9036         if (r->driver_path) {
9037                 ndr_print_string(ndr, "driver_path", r->driver_path);
9038         }
9039         ndr->depth--;
9040         ndr_print_ptr(ndr, "data_file", r->data_file);
9041         ndr->depth++;
9042         if (r->data_file) {
9043                 ndr_print_string(ndr, "data_file", r->data_file);
9044         }
9045         ndr->depth--;
9046         ndr_print_ptr(ndr, "config_file", r->config_file);
9047         ndr->depth++;
9048         if (r->config_file) {
9049                 ndr_print_string(ndr, "config_file", r->config_file);
9050         }
9051         ndr->depth--;
9052         ndr_print_ptr(ndr, "help_file", r->help_file);
9053         ndr->depth++;
9054         if (r->help_file) {
9055                 ndr_print_string(ndr, "help_file", r->help_file);
9056         }
9057         ndr->depth--;
9058         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9059         ndr->depth++;
9060         if (r->monitor_name) {
9061                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9062         }
9063         ndr->depth--;
9064         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9065         ndr->depth++;
9066         if (r->default_datatype) {
9067                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9068         }
9069         ndr->depth--;
9070         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9071         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9072         ndr->depth++;
9073         if (r->dependent_files) {
9074                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9075         }
9076         ndr->depth--;
9077         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9078         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9079         ndr->depth++;
9080         if (r->previous_names) {
9081                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9082         }
9083         ndr->depth--;
9084         ndr->depth--;
9085 }
9086
9087 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9088 {
9089         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9090         return NDR_ERR_SUCCESS;
9091 }
9092
9093 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9094 {
9095         uint32_t v;
9096         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9097         *r = v;
9098         return NDR_ERR_SUCCESS;
9099 }
9100
9101 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9102 {
9103         ndr_print_uint32(ndr, name, r);
9104         ndr->depth++;
9105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9106         ndr->depth--;
9107 }
9108
9109 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9110 {
9111         if (ndr_flags & NDR_SCALARS) {
9112                 NDR_CHECK(ndr_push_align(ndr, 8));
9113                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9115                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9126                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9127                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9132                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9133         }
9134         if (ndr_flags & NDR_BUFFERS) {
9135                 if (r->driver_name) {
9136                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9137                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9140                 }
9141                 if (r->architecture) {
9142                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9143                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9146                 }
9147                 if (r->driver_path) {
9148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9152                 }
9153                 if (r->data_file) {
9154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9158                 }
9159                 if (r->config_file) {
9160                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9163                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9164                 }
9165                 if (r->help_file) {
9166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9167                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9170                 }
9171                 if (r->monitor_name) {
9172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9173                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9176                 }
9177                 if (r->default_datatype) {
9178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9182                 }
9183                 if (r->dependent_files) {
9184                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9185                 }
9186                 if (r->previous_names) {
9187                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9188                 }
9189                 if (r->manufacturer_name) {
9190                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9193                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9194                 }
9195                 if (r->manufacturer_url) {
9196                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9200                 }
9201                 if (r->hardware_id) {
9202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9205                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9206                 }
9207                 if (r->provider) {
9208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9212                 }
9213         }
9214         return NDR_ERR_SUCCESS;
9215 }
9216
9217 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9218 {
9219         uint32_t _ptr_driver_name;
9220         TALLOC_CTX *_mem_save_driver_name_0;
9221         uint32_t _ptr_architecture;
9222         TALLOC_CTX *_mem_save_architecture_0;
9223         uint32_t _ptr_driver_path;
9224         TALLOC_CTX *_mem_save_driver_path_0;
9225         uint32_t _ptr_data_file;
9226         TALLOC_CTX *_mem_save_data_file_0;
9227         uint32_t _ptr_config_file;
9228         TALLOC_CTX *_mem_save_config_file_0;
9229         uint32_t _ptr_help_file;
9230         TALLOC_CTX *_mem_save_help_file_0;
9231         uint32_t _ptr_monitor_name;
9232         TALLOC_CTX *_mem_save_monitor_name_0;
9233         uint32_t _ptr_default_datatype;
9234         TALLOC_CTX *_mem_save_default_datatype_0;
9235         uint32_t _ptr_dependent_files;
9236         TALLOC_CTX *_mem_save_dependent_files_0;
9237         uint32_t _ptr_previous_names;
9238         TALLOC_CTX *_mem_save_previous_names_0;
9239         uint32_t _ptr_manufacturer_name;
9240         TALLOC_CTX *_mem_save_manufacturer_name_0;
9241         uint32_t _ptr_manufacturer_url;
9242         TALLOC_CTX *_mem_save_manufacturer_url_0;
9243         uint32_t _ptr_hardware_id;
9244         TALLOC_CTX *_mem_save_hardware_id_0;
9245         uint32_t _ptr_provider;
9246         TALLOC_CTX *_mem_save_provider_0;
9247         if (ndr_flags & NDR_SCALARS) {
9248                 NDR_CHECK(ndr_pull_align(ndr, 8));
9249                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9251                 if (_ptr_driver_name) {
9252                         NDR_PULL_ALLOC(ndr, r->driver_name);
9253                 } else {
9254                         r->driver_name = NULL;
9255                 }
9256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9257                 if (_ptr_architecture) {
9258                         NDR_PULL_ALLOC(ndr, r->architecture);
9259                 } else {
9260                         r->architecture = NULL;
9261                 }
9262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9263                 if (_ptr_driver_path) {
9264                         NDR_PULL_ALLOC(ndr, r->driver_path);
9265                 } else {
9266                         r->driver_path = NULL;
9267                 }
9268                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9269                 if (_ptr_data_file) {
9270                         NDR_PULL_ALLOC(ndr, r->data_file);
9271                 } else {
9272                         r->data_file = NULL;
9273                 }
9274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9275                 if (_ptr_config_file) {
9276                         NDR_PULL_ALLOC(ndr, r->config_file);
9277                 } else {
9278                         r->config_file = NULL;
9279                 }
9280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9281                 if (_ptr_help_file) {
9282                         NDR_PULL_ALLOC(ndr, r->help_file);
9283                 } else {
9284                         r->help_file = NULL;
9285                 }
9286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9287                 if (_ptr_monitor_name) {
9288                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9289                 } else {
9290                         r->monitor_name = NULL;
9291                 }
9292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9293                 if (_ptr_default_datatype) {
9294                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9295                 } else {
9296                         r->default_datatype = NULL;
9297                 }
9298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9300                 if (_ptr_dependent_files) {
9301                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9302                 } else {
9303                         r->dependent_files = NULL;
9304                 }
9305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9306                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9307                 if (_ptr_previous_names) {
9308                         NDR_PULL_ALLOC(ndr, r->previous_names);
9309                 } else {
9310                         r->previous_names = NULL;
9311                 }
9312                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9313                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9315                 if (_ptr_manufacturer_name) {
9316                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9317                 } else {
9318                         r->manufacturer_name = NULL;
9319                 }
9320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9321                 if (_ptr_manufacturer_url) {
9322                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9323                 } else {
9324                         r->manufacturer_url = NULL;
9325                 }
9326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9327                 if (_ptr_hardware_id) {
9328                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9329                 } else {
9330                         r->hardware_id = NULL;
9331                 }
9332                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9333                 if (_ptr_provider) {
9334                         NDR_PULL_ALLOC(ndr, r->provider);
9335                 } else {
9336                         r->provider = NULL;
9337                 }
9338                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9339         }
9340         if (ndr_flags & NDR_BUFFERS) {
9341                 if (r->driver_name) {
9342                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9343                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9346                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9347                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9348                         }
9349                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9352                 }
9353                 if (r->architecture) {
9354                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9355                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9358                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9359                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9360                         }
9361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9364                 }
9365                 if (r->driver_path) {
9366                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9367                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9369                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9370                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9371                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9372                         }
9373                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9374                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9376                 }
9377                 if (r->data_file) {
9378                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9379                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9382                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9383                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9384                         }
9385                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9386                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9388                 }
9389                 if (r->config_file) {
9390                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9391                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9392                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9393                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9394                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9395                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9396                         }
9397                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9398                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9400                 }
9401                 if (r->help_file) {
9402                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9403                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9405                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9406                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9407                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9408                         }
9409                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9410                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9412                 }
9413                 if (r->monitor_name) {
9414                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9415                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9417                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9418                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9419                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9420                         }
9421                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9422                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9424                 }
9425                 if (r->default_datatype) {
9426                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9427                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9429                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9430                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9431                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9432                         }
9433                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9434                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9436                 }
9437                 if (r->dependent_files) {
9438                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9439                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9440                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9442                 }
9443                 if (r->previous_names) {
9444                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9445                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9446                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9448                 }
9449                 if (r->manufacturer_name) {
9450                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9451                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9452                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9453                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9454                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9455                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9456                         }
9457                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9458                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9459                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9460                 }
9461                 if (r->manufacturer_url) {
9462                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9463                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9464                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9465                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9466                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9467                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9468                         }
9469                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9470                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9471                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9472                 }
9473                 if (r->hardware_id) {
9474                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9475                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9476                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9477                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9478                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9479                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9480                         }
9481                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9482                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9484                 }
9485                 if (r->provider) {
9486                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9487                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9490                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9491                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9492                         }
9493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9496                 }
9497         }
9498         return NDR_ERR_SUCCESS;
9499 }
9500
9501 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9502 {
9503         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9504         ndr->depth++;
9505         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9506         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9507         ndr->depth++;
9508         if (r->driver_name) {
9509                 ndr_print_string(ndr, "driver_name", r->driver_name);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "architecture", r->architecture);
9513         ndr->depth++;
9514         if (r->architecture) {
9515                 ndr_print_string(ndr, "architecture", r->architecture);
9516         }
9517         ndr->depth--;
9518         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9519         ndr->depth++;
9520         if (r->driver_path) {
9521                 ndr_print_string(ndr, "driver_path", r->driver_path);
9522         }
9523         ndr->depth--;
9524         ndr_print_ptr(ndr, "data_file", r->data_file);
9525         ndr->depth++;
9526         if (r->data_file) {
9527                 ndr_print_string(ndr, "data_file", r->data_file);
9528         }
9529         ndr->depth--;
9530         ndr_print_ptr(ndr, "config_file", r->config_file);
9531         ndr->depth++;
9532         if (r->config_file) {
9533                 ndr_print_string(ndr, "config_file", r->config_file);
9534         }
9535         ndr->depth--;
9536         ndr_print_ptr(ndr, "help_file", r->help_file);
9537         ndr->depth++;
9538         if (r->help_file) {
9539                 ndr_print_string(ndr, "help_file", r->help_file);
9540         }
9541         ndr->depth--;
9542         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9543         ndr->depth++;
9544         if (r->monitor_name) {
9545                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9546         }
9547         ndr->depth--;
9548         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9549         ndr->depth++;
9550         if (r->default_datatype) {
9551                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9552         }
9553         ndr->depth--;
9554         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9555         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9556         ndr->depth++;
9557         if (r->dependent_files) {
9558                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9559         }
9560         ndr->depth--;
9561         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9562         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9563         ndr->depth++;
9564         if (r->previous_names) {
9565                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9566         }
9567         ndr->depth--;
9568         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9569         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9570         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9571         ndr->depth++;
9572         if (r->manufacturer_name) {
9573                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9574         }
9575         ndr->depth--;
9576         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9577         ndr->depth++;
9578         if (r->manufacturer_url) {
9579                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9580         }
9581         ndr->depth--;
9582         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9583         ndr->depth++;
9584         if (r->hardware_id) {
9585                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9586         }
9587         ndr->depth--;
9588         ndr_print_ptr(ndr, "provider", r->provider);
9589         ndr->depth++;
9590         if (r->provider) {
9591                 ndr_print_string(ndr, "provider", r->provider);
9592         }
9593         ndr->depth--;
9594         ndr->depth--;
9595 }
9596
9597 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9598 {
9599         if (ndr_flags & NDR_SCALARS) {
9600                 NDR_CHECK(ndr_push_align(ndr, 8));
9601                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9614                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9615                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9628                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9629                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9630                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9631         }
9632         if (ndr_flags & NDR_BUFFERS) {
9633                 if (r->driver_name) {
9634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9638                 }
9639                 if (r->architecture) {
9640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9644                 }
9645                 if (r->driver_path) {
9646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9650                 }
9651                 if (r->data_file) {
9652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9656                 }
9657                 if (r->config_file) {
9658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9662                 }
9663                 if (r->help_file) {
9664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9667                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9668                 }
9669                 if (r->monitor_name) {
9670                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9671                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9673                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9674                 }
9675                 if (r->default_datatype) {
9676                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9677                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9680                 }
9681                 if (r->dependent_files) {
9682                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9683                 }
9684                 if (r->previous_names) {
9685                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9686                 }
9687                 if (r->manufacturer_name) {
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9692                 }
9693                 if (r->manufacturer_url) {
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9698                 }
9699                 if (r->hardware_id) {
9700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9704                 }
9705                 if (r->provider) {
9706                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9710                 }
9711                 if (r->print_processor) {
9712                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9713                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9716                 }
9717                 if (r->vendor_setup) {
9718                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9719                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9722                 }
9723                 if (r->color_profiles) {
9724                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9725                 }
9726                 if (r->inf_path) {
9727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9731                 }
9732                 if (r->core_driver_dependencies) {
9733                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9734                 }
9735         }
9736         return NDR_ERR_SUCCESS;
9737 }
9738
9739 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9740 {
9741         uint32_t _ptr_driver_name;
9742         TALLOC_CTX *_mem_save_driver_name_0;
9743         uint32_t _ptr_architecture;
9744         TALLOC_CTX *_mem_save_architecture_0;
9745         uint32_t _ptr_driver_path;
9746         TALLOC_CTX *_mem_save_driver_path_0;
9747         uint32_t _ptr_data_file;
9748         TALLOC_CTX *_mem_save_data_file_0;
9749         uint32_t _ptr_config_file;
9750         TALLOC_CTX *_mem_save_config_file_0;
9751         uint32_t _ptr_help_file;
9752         TALLOC_CTX *_mem_save_help_file_0;
9753         uint32_t _ptr_monitor_name;
9754         TALLOC_CTX *_mem_save_monitor_name_0;
9755         uint32_t _ptr_default_datatype;
9756         TALLOC_CTX *_mem_save_default_datatype_0;
9757         uint32_t _ptr_dependent_files;
9758         TALLOC_CTX *_mem_save_dependent_files_0;
9759         uint32_t _ptr_previous_names;
9760         TALLOC_CTX *_mem_save_previous_names_0;
9761         uint32_t _ptr_manufacturer_name;
9762         TALLOC_CTX *_mem_save_manufacturer_name_0;
9763         uint32_t _ptr_manufacturer_url;
9764         TALLOC_CTX *_mem_save_manufacturer_url_0;
9765         uint32_t _ptr_hardware_id;
9766         TALLOC_CTX *_mem_save_hardware_id_0;
9767         uint32_t _ptr_provider;
9768         TALLOC_CTX *_mem_save_provider_0;
9769         uint32_t _ptr_print_processor;
9770         TALLOC_CTX *_mem_save_print_processor_0;
9771         uint32_t _ptr_vendor_setup;
9772         TALLOC_CTX *_mem_save_vendor_setup_0;
9773         uint32_t _ptr_color_profiles;
9774         TALLOC_CTX *_mem_save_color_profiles_0;
9775         uint32_t _ptr_inf_path;
9776         TALLOC_CTX *_mem_save_inf_path_0;
9777         uint32_t _ptr_core_driver_dependencies;
9778         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9779         if (ndr_flags & NDR_SCALARS) {
9780                 NDR_CHECK(ndr_pull_align(ndr, 8));
9781                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9783                 if (_ptr_driver_name) {
9784                         NDR_PULL_ALLOC(ndr, r->driver_name);
9785                 } else {
9786                         r->driver_name = NULL;
9787                 }
9788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9789                 if (_ptr_architecture) {
9790                         NDR_PULL_ALLOC(ndr, r->architecture);
9791                 } else {
9792                         r->architecture = NULL;
9793                 }
9794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9795                 if (_ptr_driver_path) {
9796                         NDR_PULL_ALLOC(ndr, r->driver_path);
9797                 } else {
9798                         r->driver_path = NULL;
9799                 }
9800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9801                 if (_ptr_data_file) {
9802                         NDR_PULL_ALLOC(ndr, r->data_file);
9803                 } else {
9804                         r->data_file = NULL;
9805                 }
9806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9807                 if (_ptr_config_file) {
9808                         NDR_PULL_ALLOC(ndr, r->config_file);
9809                 } else {
9810                         r->config_file = NULL;
9811                 }
9812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9813                 if (_ptr_help_file) {
9814                         NDR_PULL_ALLOC(ndr, r->help_file);
9815                 } else {
9816                         r->help_file = NULL;
9817                 }
9818                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9819                 if (_ptr_monitor_name) {
9820                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9821                 } else {
9822                         r->monitor_name = NULL;
9823                 }
9824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9825                 if (_ptr_default_datatype) {
9826                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9827                 } else {
9828                         r->default_datatype = NULL;
9829                 }
9830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9832                 if (_ptr_dependent_files) {
9833                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9834                 } else {
9835                         r->dependent_files = NULL;
9836                 }
9837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9839                 if (_ptr_previous_names) {
9840                         NDR_PULL_ALLOC(ndr, r->previous_names);
9841                 } else {
9842                         r->previous_names = NULL;
9843                 }
9844                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9845                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9847                 if (_ptr_manufacturer_name) {
9848                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9849                 } else {
9850                         r->manufacturer_name = NULL;
9851                 }
9852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9853                 if (_ptr_manufacturer_url) {
9854                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9855                 } else {
9856                         r->manufacturer_url = NULL;
9857                 }
9858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9859                 if (_ptr_hardware_id) {
9860                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9861                 } else {
9862                         r->hardware_id = NULL;
9863                 }
9864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9865                 if (_ptr_provider) {
9866                         NDR_PULL_ALLOC(ndr, r->provider);
9867                 } else {
9868                         r->provider = NULL;
9869                 }
9870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9871                 if (_ptr_print_processor) {
9872                         NDR_PULL_ALLOC(ndr, r->print_processor);
9873                 } else {
9874                         r->print_processor = NULL;
9875                 }
9876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9877                 if (_ptr_vendor_setup) {
9878                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9879                 } else {
9880                         r->vendor_setup = NULL;
9881                 }
9882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9884                 if (_ptr_color_profiles) {
9885                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9886                 } else {
9887                         r->color_profiles = NULL;
9888                 }
9889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9890                 if (_ptr_inf_path) {
9891                         NDR_PULL_ALLOC(ndr, r->inf_path);
9892                 } else {
9893                         r->inf_path = NULL;
9894                 }
9895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9898                 if (_ptr_core_driver_dependencies) {
9899                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9900                 } else {
9901                         r->core_driver_dependencies = NULL;
9902                 }
9903                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9904                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9905                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9906         }
9907         if (ndr_flags & NDR_BUFFERS) {
9908                 if (r->driver_name) {
9909                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9910                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9913                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9914                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9915                         }
9916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9919                 }
9920                 if (r->architecture) {
9921                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9922                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9925                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9926                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9927                         }
9928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9931                 }
9932                 if (r->driver_path) {
9933                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9934                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9937                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9938                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9939                         }
9940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9943                 }
9944                 if (r->data_file) {
9945                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9946                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9947                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9948                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9949                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9950                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9951                         }
9952                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9953                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9955                 }
9956                 if (r->config_file) {
9957                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9958                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9961                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9962                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9963                         }
9964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9967                 }
9968                 if (r->help_file) {
9969                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9970                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9973                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9974                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9975                         }
9976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9979                 }
9980                 if (r->monitor_name) {
9981                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9982                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9985                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9986                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9987                         }
9988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9991                 }
9992                 if (r->default_datatype) {
9993                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9994                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9997                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9998                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9999                         }
10000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10003                 }
10004                 if (r->dependent_files) {
10005                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10007                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10009                 }
10010                 if (r->previous_names) {
10011                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10012                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10013                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10015                 }
10016                 if (r->manufacturer_name) {
10017                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10018                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10021                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10022                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
10023                         }
10024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10027                 }
10028                 if (r->manufacturer_url) {
10029                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10033                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10034                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
10035                         }
10036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10037                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10039                 }
10040                 if (r->hardware_id) {
10041                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10042                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10045                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10046                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
10047                         }
10048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10049                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10051                 }
10052                 if (r->provider) {
10053                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10054                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10057                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10058                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
10059                         }
10060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10063                 }
10064                 if (r->print_processor) {
10065                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10066                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10069                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10070                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
10071                         }
10072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10075                 }
10076                 if (r->vendor_setup) {
10077                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10078                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10081                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10082                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
10083                         }
10084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10087                 }
10088                 if (r->color_profiles) {
10089                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10090                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10091                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10093                 }
10094                 if (r->inf_path) {
10095                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10096                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10099                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10100                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
10101                         }
10102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10105                 }
10106                 if (r->core_driver_dependencies) {
10107                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10108                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10109                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10111                 }
10112         }
10113         return NDR_ERR_SUCCESS;
10114 }
10115
10116 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10117 {
10118         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10119         ndr->depth++;
10120         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10121         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10122         ndr->depth++;
10123         if (r->driver_name) {
10124                 ndr_print_string(ndr, "driver_name", r->driver_name);
10125         }
10126         ndr->depth--;
10127         ndr_print_ptr(ndr, "architecture", r->architecture);
10128         ndr->depth++;
10129         if (r->architecture) {
10130                 ndr_print_string(ndr, "architecture", r->architecture);
10131         }
10132         ndr->depth--;
10133         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10134         ndr->depth++;
10135         if (r->driver_path) {
10136                 ndr_print_string(ndr, "driver_path", r->driver_path);
10137         }
10138         ndr->depth--;
10139         ndr_print_ptr(ndr, "data_file", r->data_file);
10140         ndr->depth++;
10141         if (r->data_file) {
10142                 ndr_print_string(ndr, "data_file", r->data_file);
10143         }
10144         ndr->depth--;
10145         ndr_print_ptr(ndr, "config_file", r->config_file);
10146         ndr->depth++;
10147         if (r->config_file) {
10148                 ndr_print_string(ndr, "config_file", r->config_file);
10149         }
10150         ndr->depth--;
10151         ndr_print_ptr(ndr, "help_file", r->help_file);
10152         ndr->depth++;
10153         if (r->help_file) {
10154                 ndr_print_string(ndr, "help_file", r->help_file);
10155         }
10156         ndr->depth--;
10157         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10158         ndr->depth++;
10159         if (r->monitor_name) {
10160                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10161         }
10162         ndr->depth--;
10163         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10164         ndr->depth++;
10165         if (r->default_datatype) {
10166                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10167         }
10168         ndr->depth--;
10169         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
10170         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10171         ndr->depth++;
10172         if (r->dependent_files) {
10173                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10174         }
10175         ndr->depth--;
10176         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
10177         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10178         ndr->depth++;
10179         if (r->previous_names) {
10180                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10181         }
10182         ndr->depth--;
10183         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10184         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10185         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10186         ndr->depth++;
10187         if (r->manufacturer_name) {
10188                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10189         }
10190         ndr->depth--;
10191         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10192         ndr->depth++;
10193         if (r->manufacturer_url) {
10194                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10195         }
10196         ndr->depth--;
10197         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10198         ndr->depth++;
10199         if (r->hardware_id) {
10200                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10201         }
10202         ndr->depth--;
10203         ndr_print_ptr(ndr, "provider", r->provider);
10204         ndr->depth++;
10205         if (r->provider) {
10206                 ndr_print_string(ndr, "provider", r->provider);
10207         }
10208         ndr->depth--;
10209         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10210         ndr->depth++;
10211         if (r->print_processor) {
10212                 ndr_print_string(ndr, "print_processor", r->print_processor);
10213         }
10214         ndr->depth--;
10215         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10216         ndr->depth++;
10217         if (r->vendor_setup) {
10218                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10219         }
10220         ndr->depth--;
10221         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
10222         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10223         ndr->depth++;
10224         if (r->color_profiles) {
10225                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10226         }
10227         ndr->depth--;
10228         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10229         ndr->depth++;
10230         if (r->inf_path) {
10231                 ndr_print_string(ndr, "inf_path", r->inf_path);
10232         }
10233         ndr->depth--;
10234         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10235         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
10236         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10237         ndr->depth++;
10238         if (r->core_driver_dependencies) {
10239                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10240         }
10241         ndr->depth--;
10242         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10243         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10244         ndr->depth--;
10245 }
10246
10247 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10248 {
10249         if (ndr_flags & NDR_SCALARS) {
10250                 int level = ndr_push_get_switch_value(ndr, r);
10251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10252                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10253                 switch (level) {
10254                         case 1: {
10255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10256                         break; }
10257
10258                         case 2: {
10259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10260                         break; }
10261
10262                         case 3: {
10263                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10264                         break; }
10265
10266                         case 4: {
10267                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10268                         break; }
10269
10270                         case 6: {
10271                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10272                         break; }
10273
10274                         case 8: {
10275                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10276                         break; }
10277
10278                         default:
10279                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10280                 }
10281         }
10282         if (ndr_flags & NDR_BUFFERS) {
10283                 int level = ndr_push_get_switch_value(ndr, r);
10284                 switch (level) {
10285                         case 1:
10286                                 if (r->info1) {
10287                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10288                                 }
10289                         break;
10290
10291                         case 2:
10292                                 if (r->info2) {
10293                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10294                                 }
10295                         break;
10296
10297                         case 3:
10298                                 if (r->info3) {
10299                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10300                                 }
10301                         break;
10302
10303                         case 4:
10304                                 if (r->info4) {
10305                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10306                                 }
10307                         break;
10308
10309                         case 6:
10310                                 if (r->info6) {
10311                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10312                                 }
10313                         break;
10314
10315                         case 8:
10316                                 if (r->info8) {
10317                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10318                                 }
10319                         break;
10320
10321                         default:
10322                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10323                 }
10324         }
10325         return NDR_ERR_SUCCESS;
10326 }
10327
10328 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10329 {
10330         int level;
10331         uint32_t _level;
10332         TALLOC_CTX *_mem_save_info1_0;
10333         TALLOC_CTX *_mem_save_info2_0;
10334         TALLOC_CTX *_mem_save_info3_0;
10335         TALLOC_CTX *_mem_save_info4_0;
10336         TALLOC_CTX *_mem_save_info6_0;
10337         TALLOC_CTX *_mem_save_info8_0;
10338         level = ndr_pull_get_switch_value(ndr, r);
10339         if (ndr_flags & NDR_SCALARS) {
10340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10341                 if (_level != level) {
10342                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10343                 }
10344                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10345                 switch (level) {
10346                         case 1: {
10347                                 uint32_t _ptr_info1;
10348                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10349                                 if (_ptr_info1) {
10350                                         NDR_PULL_ALLOC(ndr, r->info1);
10351                                 } else {
10352                                         r->info1 = NULL;
10353                                 }
10354                         break; }
10355
10356                         case 2: {
10357                                 uint32_t _ptr_info2;
10358                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10359                                 if (_ptr_info2) {
10360                                         NDR_PULL_ALLOC(ndr, r->info2);
10361                                 } else {
10362                                         r->info2 = NULL;
10363                                 }
10364                         break; }
10365
10366                         case 3: {
10367                                 uint32_t _ptr_info3;
10368                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10369                                 if (_ptr_info3) {
10370                                         NDR_PULL_ALLOC(ndr, r->info3);
10371                                 } else {
10372                                         r->info3 = NULL;
10373                                 }
10374                         break; }
10375
10376                         case 4: {
10377                                 uint32_t _ptr_info4;
10378                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10379                                 if (_ptr_info4) {
10380                                         NDR_PULL_ALLOC(ndr, r->info4);
10381                                 } else {
10382                                         r->info4 = NULL;
10383                                 }
10384                         break; }
10385
10386                         case 6: {
10387                                 uint32_t _ptr_info6;
10388                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10389                                 if (_ptr_info6) {
10390                                         NDR_PULL_ALLOC(ndr, r->info6);
10391                                 } else {
10392                                         r->info6 = NULL;
10393                                 }
10394                         break; }
10395
10396                         case 8: {
10397                                 uint32_t _ptr_info8;
10398                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10399                                 if (_ptr_info8) {
10400                                         NDR_PULL_ALLOC(ndr, r->info8);
10401                                 } else {
10402                                         r->info8 = NULL;
10403                                 }
10404                         break; }
10405
10406                         default:
10407                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10408                 }
10409         }
10410         if (ndr_flags & NDR_BUFFERS) {
10411                 switch (level) {
10412                         case 1:
10413                                 if (r->info1) {
10414                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10415                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10416                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10417                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10418                                 }
10419                         break;
10420
10421                         case 2:
10422                                 if (r->info2) {
10423                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10424                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10425                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10426                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10427                                 }
10428                         break;
10429
10430                         case 3:
10431                                 if (r->info3) {
10432                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10433                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10434                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10435                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10436                                 }
10437                         break;
10438
10439                         case 4:
10440                                 if (r->info4) {
10441                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10442                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10443                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10444                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10445                                 }
10446                         break;
10447
10448                         case 6:
10449                                 if (r->info6) {
10450                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10452                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10453                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10454                                 }
10455                         break;
10456
10457                         case 8:
10458                                 if (r->info8) {
10459                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10460                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10461                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10462                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10463                                 }
10464                         break;
10465
10466                         default:
10467                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10468                 }
10469         }
10470         return NDR_ERR_SUCCESS;
10471 }
10472
10473 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10474 {
10475         int level;
10476         level = ndr_print_get_switch_value(ndr, r);
10477         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10478         switch (level) {
10479                 case 1:
10480                         ndr_print_ptr(ndr, "info1", r->info1);
10481                         ndr->depth++;
10482                         if (r->info1) {
10483                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10484                         }
10485                         ndr->depth--;
10486                 break;
10487
10488                 case 2:
10489                         ndr_print_ptr(ndr, "info2", r->info2);
10490                         ndr->depth++;
10491                         if (r->info2) {
10492                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10493                         }
10494                         ndr->depth--;
10495                 break;
10496
10497                 case 3:
10498                         ndr_print_ptr(ndr, "info3", r->info3);
10499                         ndr->depth++;
10500                         if (r->info3) {
10501                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10502                         }
10503                         ndr->depth--;
10504                 break;
10505
10506                 case 4:
10507                         ndr_print_ptr(ndr, "info4", r->info4);
10508                         ndr->depth++;
10509                         if (r->info4) {
10510                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10511                         }
10512                         ndr->depth--;
10513                 break;
10514
10515                 case 6:
10516                         ndr_print_ptr(ndr, "info6", r->info6);
10517                         ndr->depth++;
10518                         if (r->info6) {
10519                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10520                         }
10521                         ndr->depth--;
10522                 break;
10523
10524                 case 8:
10525                         ndr_print_ptr(ndr, "info8", r->info8);
10526                         ndr->depth++;
10527                         if (r->info8) {
10528                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10529                         }
10530                         ndr->depth--;
10531                 break;
10532
10533                 default:
10534                         ndr_print_bad_level(ndr, name, level);
10535         }
10536 }
10537
10538 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10539 {
10540         if (ndr_flags & NDR_SCALARS) {
10541                 NDR_CHECK(ndr_push_align(ndr, 5));
10542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10543                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10544                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10545                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10546         }
10547         if (ndr_flags & NDR_BUFFERS) {
10548                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10549         }
10550         return NDR_ERR_SUCCESS;
10551 }
10552
10553 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10554 {
10555         if (ndr_flags & NDR_SCALARS) {
10556                 NDR_CHECK(ndr_pull_align(ndr, 5));
10557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10558                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10559                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10560                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10561         }
10562         if (ndr_flags & NDR_BUFFERS) {
10563                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10564         }
10565         return NDR_ERR_SUCCESS;
10566 }
10567
10568 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10569 {
10570         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10571         ndr->depth++;
10572         ndr_print_uint32(ndr, "level", r->level);
10573         ndr_print_set_switch_value(ndr, &r->info, r->level);
10574         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10575         ndr->depth--;
10576 }
10577
10578 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10579 {
10580         if (ndr_flags & NDR_SCALARS) {
10581                 NDR_CHECK(ndr_push_align(ndr, 5));
10582                 {
10583                         uint32_t _flags_save_string = ndr->flags;
10584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10585                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10586                         ndr->flags = _flags_save_string;
10587                 }
10588                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10589         }
10590         if (ndr_flags & NDR_BUFFERS) {
10591                 {
10592                         uint32_t _flags_save_string = ndr->flags;
10593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10594                         if (r->driver_name) {
10595                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10596                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10597                         }
10598                         ndr->flags = _flags_save_string;
10599                 }
10600         }
10601         return NDR_ERR_SUCCESS;
10602 }
10603
10604 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10605 {
10606         uint32_t _ptr_driver_name;
10607         TALLOC_CTX *_mem_save_driver_name_0;
10608         if (ndr_flags & NDR_SCALARS) {
10609                 NDR_CHECK(ndr_pull_align(ndr, 5));
10610                 {
10611                         uint32_t _flags_save_string = ndr->flags;
10612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10613                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10614                         if (_ptr_driver_name) {
10615                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10616                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10617                         } else {
10618                                 r->driver_name = NULL;
10619                         }
10620                         ndr->flags = _flags_save_string;
10621                 }
10622                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10623         }
10624         if (ndr_flags & NDR_BUFFERS) {
10625                 {
10626                         uint32_t _flags_save_string = ndr->flags;
10627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10628                         if (r->driver_name) {
10629                                 uint32_t _relative_save_offset;
10630                                 _relative_save_offset = ndr->offset;
10631                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10632                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10633                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10634                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10635                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10636                                 if (ndr->offset > ndr->relative_highest_offset) {
10637                                         ndr->relative_highest_offset = ndr->offset;
10638                                 }
10639                                 ndr->offset = _relative_save_offset;
10640                         }
10641                         ndr->flags = _flags_save_string;
10642                 }
10643         }
10644         return NDR_ERR_SUCCESS;
10645 }
10646
10647 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10648 {
10649         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10650         ndr->depth++;
10651         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10652         ndr->depth++;
10653         if (r->driver_name) {
10654                 ndr_print_string(ndr, "driver_name", r->driver_name);
10655         }
10656         ndr->depth--;
10657         ndr->depth--;
10658 }
10659
10660 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10661 {
10662         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10663 }
10664
10665 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10666 {
10667         if (ndr_flags & NDR_SCALARS) {
10668                 NDR_CHECK(ndr_push_align(ndr, 5));
10669                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10670                 {
10671                         uint32_t _flags_save_string = ndr->flags;
10672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10673                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10674                         ndr->flags = _flags_save_string;
10675                 }
10676                 {
10677                         uint32_t _flags_save_string = ndr->flags;
10678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10679                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10680                         ndr->flags = _flags_save_string;
10681                 }
10682                 {
10683                         uint32_t _flags_save_string = ndr->flags;
10684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10685                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10686                         ndr->flags = _flags_save_string;
10687                 }
10688                 {
10689                         uint32_t _flags_save_string = ndr->flags;
10690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10691                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10692                         ndr->flags = _flags_save_string;
10693                 }
10694                 {
10695                         uint32_t _flags_save_string = ndr->flags;
10696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10697                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10698                         ndr->flags = _flags_save_string;
10699                 }
10700                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10701         }
10702         if (ndr_flags & NDR_BUFFERS) {
10703                 {
10704                         uint32_t _flags_save_string = ndr->flags;
10705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10706                         if (r->driver_name) {
10707                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10709                         }
10710                         ndr->flags = _flags_save_string;
10711                 }
10712                 {
10713                         uint32_t _flags_save_string = ndr->flags;
10714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10715                         if (r->architecture) {
10716                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10717                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10718                         }
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         if (r->driver_path) {
10725                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10726                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10727                         }
10728                         ndr->flags = _flags_save_string;
10729                 }
10730                 {
10731                         uint32_t _flags_save_string = ndr->flags;
10732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10733                         if (r->data_file) {
10734                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10735                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10736                         }
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         if (r->config_file) {
10743                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10744                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10745                         }
10746                         ndr->flags = _flags_save_string;
10747                 }
10748         }
10749         return NDR_ERR_SUCCESS;
10750 }
10751
10752 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10753 {
10754         uint32_t _ptr_driver_name;
10755         TALLOC_CTX *_mem_save_driver_name_0;
10756         uint32_t _ptr_architecture;
10757         TALLOC_CTX *_mem_save_architecture_0;
10758         uint32_t _ptr_driver_path;
10759         TALLOC_CTX *_mem_save_driver_path_0;
10760         uint32_t _ptr_data_file;
10761         TALLOC_CTX *_mem_save_data_file_0;
10762         uint32_t _ptr_config_file;
10763         TALLOC_CTX *_mem_save_config_file_0;
10764         if (ndr_flags & NDR_SCALARS) {
10765                 NDR_CHECK(ndr_pull_align(ndr, 5));
10766                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10767                 {
10768                         uint32_t _flags_save_string = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10771                         if (_ptr_driver_name) {
10772                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10773                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10774                         } else {
10775                                 r->driver_name = NULL;
10776                         }
10777                         ndr->flags = _flags_save_string;
10778                 }
10779                 {
10780                         uint32_t _flags_save_string = ndr->flags;
10781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10782                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10783                         if (_ptr_architecture) {
10784                                 NDR_PULL_ALLOC(ndr, r->architecture);
10785                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10786                         } else {
10787                                 r->architecture = NULL;
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10795                         if (_ptr_driver_path) {
10796                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10797                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10798                         } else {
10799                                 r->driver_path = NULL;
10800                         }
10801                         ndr->flags = _flags_save_string;
10802                 }
10803                 {
10804                         uint32_t _flags_save_string = ndr->flags;
10805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10806                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10807                         if (_ptr_data_file) {
10808                                 NDR_PULL_ALLOC(ndr, r->data_file);
10809                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10810                         } else {
10811                                 r->data_file = NULL;
10812                         }
10813                         ndr->flags = _flags_save_string;
10814                 }
10815                 {
10816                         uint32_t _flags_save_string = ndr->flags;
10817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10818                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10819                         if (_ptr_config_file) {
10820                                 NDR_PULL_ALLOC(ndr, r->config_file);
10821                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10822                         } else {
10823                                 r->config_file = NULL;
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10828         }
10829         if (ndr_flags & NDR_BUFFERS) {
10830                 {
10831                         uint32_t _flags_save_string = ndr->flags;
10832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10833                         if (r->driver_name) {
10834                                 uint32_t _relative_save_offset;
10835                                 _relative_save_offset = ndr->offset;
10836                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10837                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10838                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10839                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10840                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10841                                 if (ndr->offset > ndr->relative_highest_offset) {
10842                                         ndr->relative_highest_offset = ndr->offset;
10843                                 }
10844                                 ndr->offset = _relative_save_offset;
10845                         }
10846                         ndr->flags = _flags_save_string;
10847                 }
10848                 {
10849                         uint32_t _flags_save_string = ndr->flags;
10850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10851                         if (r->architecture) {
10852                                 uint32_t _relative_save_offset;
10853                                 _relative_save_offset = ndr->offset;
10854                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10855                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10856                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10857                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10858                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10859                                 if (ndr->offset > ndr->relative_highest_offset) {
10860                                         ndr->relative_highest_offset = ndr->offset;
10861                                 }
10862                                 ndr->offset = _relative_save_offset;
10863                         }
10864                         ndr->flags = _flags_save_string;
10865                 }
10866                 {
10867                         uint32_t _flags_save_string = ndr->flags;
10868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10869                         if (r->driver_path) {
10870                                 uint32_t _relative_save_offset;
10871                                 _relative_save_offset = ndr->offset;
10872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10873                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10874                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10877                                 if (ndr->offset > ndr->relative_highest_offset) {
10878                                         ndr->relative_highest_offset = ndr->offset;
10879                                 }
10880                                 ndr->offset = _relative_save_offset;
10881                         }
10882                         ndr->flags = _flags_save_string;
10883                 }
10884                 {
10885                         uint32_t _flags_save_string = ndr->flags;
10886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10887                         if (r->data_file) {
10888                                 uint32_t _relative_save_offset;
10889                                 _relative_save_offset = ndr->offset;
10890                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10891                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10892                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10893                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10894                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10895                                 if (ndr->offset > ndr->relative_highest_offset) {
10896                                         ndr->relative_highest_offset = ndr->offset;
10897                                 }
10898                                 ndr->offset = _relative_save_offset;
10899                         }
10900                         ndr->flags = _flags_save_string;
10901                 }
10902                 {
10903                         uint32_t _flags_save_string = ndr->flags;
10904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10905                         if (r->config_file) {
10906                                 uint32_t _relative_save_offset;
10907                                 _relative_save_offset = ndr->offset;
10908                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10909                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10911                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10912                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10913                                 if (ndr->offset > ndr->relative_highest_offset) {
10914                                         ndr->relative_highest_offset = ndr->offset;
10915                                 }
10916                                 ndr->offset = _relative_save_offset;
10917                         }
10918                         ndr->flags = _flags_save_string;
10919                 }
10920         }
10921         return NDR_ERR_SUCCESS;
10922 }
10923
10924 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10925 {
10926         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10927         ndr->depth++;
10928         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10929         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10930         ndr->depth++;
10931         if (r->driver_name) {
10932                 ndr_print_string(ndr, "driver_name", r->driver_name);
10933         }
10934         ndr->depth--;
10935         ndr_print_ptr(ndr, "architecture", r->architecture);
10936         ndr->depth++;
10937         if (r->architecture) {
10938                 ndr_print_string(ndr, "architecture", r->architecture);
10939         }
10940         ndr->depth--;
10941         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10942         ndr->depth++;
10943         if (r->driver_path) {
10944                 ndr_print_string(ndr, "driver_path", r->driver_path);
10945         }
10946         ndr->depth--;
10947         ndr_print_ptr(ndr, "data_file", r->data_file);
10948         ndr->depth++;
10949         if (r->data_file) {
10950                 ndr_print_string(ndr, "data_file", r->data_file);
10951         }
10952         ndr->depth--;
10953         ndr_print_ptr(ndr, "config_file", r->config_file);
10954         ndr->depth++;
10955         if (r->config_file) {
10956                 ndr_print_string(ndr, "config_file", r->config_file);
10957         }
10958         ndr->depth--;
10959         ndr->depth--;
10960 }
10961
10962 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10963 {
10964         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10965 }
10966
10967 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10968 {
10969         if (ndr_flags & NDR_SCALARS) {
10970                 NDR_CHECK(ndr_push_align(ndr, 5));
10971                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10976                         ndr->flags = _flags_save_string;
10977                 }
10978                 {
10979                         uint32_t _flags_save_string = ndr->flags;
10980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10982                         ndr->flags = _flags_save_string;
10983                 }
10984                 {
10985                         uint32_t _flags_save_string = ndr->flags;
10986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10988                         ndr->flags = _flags_save_string;
10989                 }
10990                 {
10991                         uint32_t _flags_save_string = ndr->flags;
10992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10994                         ndr->flags = _flags_save_string;
10995                 }
10996                 {
10997                         uint32_t _flags_save_string = ndr->flags;
10998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11006                         ndr->flags = _flags_save_string;
11007                 }
11008                 {
11009                         uint32_t _flags_save_string_array = ndr->flags;
11010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11012                         ndr->flags = _flags_save_string_array;
11013                 }
11014                 {
11015                         uint32_t _flags_save_string = ndr->flags;
11016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11018                         ndr->flags = _flags_save_string;
11019                 }
11020                 {
11021                         uint32_t _flags_save_string = ndr->flags;
11022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11023                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11027         }
11028         if (ndr_flags & NDR_BUFFERS) {
11029                 {
11030                         uint32_t _flags_save_string = ndr->flags;
11031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11032                         if (r->driver_name) {
11033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11035                         }
11036                         ndr->flags = _flags_save_string;
11037                 }
11038                 {
11039                         uint32_t _flags_save_string = ndr->flags;
11040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11041                         if (r->architecture) {
11042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->driver_path) {
11051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11053                         }
11054                         ndr->flags = _flags_save_string;
11055                 }
11056                 {
11057                         uint32_t _flags_save_string = ndr->flags;
11058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11059                         if (r->data_file) {
11060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11062                         }
11063                         ndr->flags = _flags_save_string;
11064                 }
11065                 {
11066                         uint32_t _flags_save_string = ndr->flags;
11067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11068                         if (r->config_file) {
11069                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11070                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11071                         }
11072                         ndr->flags = _flags_save_string;
11073                 }
11074                 {
11075                         uint32_t _flags_save_string = ndr->flags;
11076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11077                         if (r->help_file) {
11078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11080                         }
11081                         ndr->flags = _flags_save_string;
11082                 }
11083                 {
11084                         uint32_t _flags_save_string_array = ndr->flags;
11085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11086                         if (r->dependent_files) {
11087                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11088                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11089                         }
11090                         ndr->flags = _flags_save_string_array;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->monitor_name) {
11096                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11097                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11098                         }
11099                         ndr->flags = _flags_save_string;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->default_datatype) {
11105                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11106                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11107                         }
11108                         ndr->flags = _flags_save_string;
11109                 }
11110         }
11111         return NDR_ERR_SUCCESS;
11112 }
11113
11114 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11115 {
11116         uint32_t _ptr_driver_name;
11117         TALLOC_CTX *_mem_save_driver_name_0;
11118         uint32_t _ptr_architecture;
11119         TALLOC_CTX *_mem_save_architecture_0;
11120         uint32_t _ptr_driver_path;
11121         TALLOC_CTX *_mem_save_driver_path_0;
11122         uint32_t _ptr_data_file;
11123         TALLOC_CTX *_mem_save_data_file_0;
11124         uint32_t _ptr_config_file;
11125         TALLOC_CTX *_mem_save_config_file_0;
11126         uint32_t _ptr_help_file;
11127         TALLOC_CTX *_mem_save_help_file_0;
11128         uint32_t _ptr_dependent_files;
11129         TALLOC_CTX *_mem_save_dependent_files_0;
11130         uint32_t _ptr_monitor_name;
11131         TALLOC_CTX *_mem_save_monitor_name_0;
11132         uint32_t _ptr_default_datatype;
11133         TALLOC_CTX *_mem_save_default_datatype_0;
11134         if (ndr_flags & NDR_SCALARS) {
11135                 NDR_CHECK(ndr_pull_align(ndr, 5));
11136                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11137                 {
11138                         uint32_t _flags_save_string = ndr->flags;
11139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11140                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11141                         if (_ptr_driver_name) {
11142                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11143                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11144                         } else {
11145                                 r->driver_name = NULL;
11146                         }
11147                         ndr->flags = _flags_save_string;
11148                 }
11149                 {
11150                         uint32_t _flags_save_string = ndr->flags;
11151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11152                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11153                         if (_ptr_architecture) {
11154                                 NDR_PULL_ALLOC(ndr, r->architecture);
11155                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11156                         } else {
11157                                 r->architecture = NULL;
11158                         }
11159                         ndr->flags = _flags_save_string;
11160                 }
11161                 {
11162                         uint32_t _flags_save_string = ndr->flags;
11163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11164                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11165                         if (_ptr_driver_path) {
11166                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11167                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11168                         } else {
11169                                 r->driver_path = NULL;
11170                         }
11171                         ndr->flags = _flags_save_string;
11172                 }
11173                 {
11174                         uint32_t _flags_save_string = ndr->flags;
11175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11176                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11177                         if (_ptr_data_file) {
11178                                 NDR_PULL_ALLOC(ndr, r->data_file);
11179                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11180                         } else {
11181                                 r->data_file = NULL;
11182                         }
11183                         ndr->flags = _flags_save_string;
11184                 }
11185                 {
11186                         uint32_t _flags_save_string = ndr->flags;
11187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11188                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11189                         if (_ptr_config_file) {
11190                                 NDR_PULL_ALLOC(ndr, r->config_file);
11191                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11192                         } else {
11193                                 r->config_file = NULL;
11194                         }
11195                         ndr->flags = _flags_save_string;
11196                 }
11197                 {
11198                         uint32_t _flags_save_string = ndr->flags;
11199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11200                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11201                         if (_ptr_help_file) {
11202                                 NDR_PULL_ALLOC(ndr, r->help_file);
11203                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11204                         } else {
11205                                 r->help_file = NULL;
11206                         }
11207                         ndr->flags = _flags_save_string;
11208                 }
11209                 {
11210                         uint32_t _flags_save_string_array = ndr->flags;
11211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11213                         if (_ptr_dependent_files) {
11214                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11216                         } else {
11217                                 r->dependent_files = NULL;
11218                         }
11219                         ndr->flags = _flags_save_string_array;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11225                         if (_ptr_monitor_name) {
11226                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11228                         } else {
11229                                 r->monitor_name = NULL;
11230                         }
11231                         ndr->flags = _flags_save_string;
11232                 }
11233                 {
11234                         uint32_t _flags_save_string = ndr->flags;
11235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11237                         if (_ptr_default_datatype) {
11238                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11240                         } else {
11241                                 r->default_datatype = NULL;
11242                         }
11243                         ndr->flags = _flags_save_string;
11244                 }
11245                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11246         }
11247         if (ndr_flags & NDR_BUFFERS) {
11248                 {
11249                         uint32_t _flags_save_string = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         if (r->driver_name) {
11252                                 uint32_t _relative_save_offset;
11253                                 _relative_save_offset = ndr->offset;
11254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11255                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11256                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11257                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11259                                 if (ndr->offset > ndr->relative_highest_offset) {
11260                                         ndr->relative_highest_offset = ndr->offset;
11261                                 }
11262                                 ndr->offset = _relative_save_offset;
11263                         }
11264                         ndr->flags = _flags_save_string;
11265                 }
11266                 {
11267                         uint32_t _flags_save_string = ndr->flags;
11268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11269                         if (r->architecture) {
11270                                 uint32_t _relative_save_offset;
11271                                 _relative_save_offset = ndr->offset;
11272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11273                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11274                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11277                                 if (ndr->offset > ndr->relative_highest_offset) {
11278                                         ndr->relative_highest_offset = ndr->offset;
11279                                 }
11280                                 ndr->offset = _relative_save_offset;
11281                         }
11282                         ndr->flags = _flags_save_string;
11283                 }
11284                 {
11285                         uint32_t _flags_save_string = ndr->flags;
11286                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11287                         if (r->driver_path) {
11288                                 uint32_t _relative_save_offset;
11289                                 _relative_save_offset = ndr->offset;
11290                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11291                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11292                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11293                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11294                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11295                                 if (ndr->offset > ndr->relative_highest_offset) {
11296                                         ndr->relative_highest_offset = ndr->offset;
11297                                 }
11298                                 ndr->offset = _relative_save_offset;
11299                         }
11300                         ndr->flags = _flags_save_string;
11301                 }
11302                 {
11303                         uint32_t _flags_save_string = ndr->flags;
11304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11305                         if (r->data_file) {
11306                                 uint32_t _relative_save_offset;
11307                                 _relative_save_offset = ndr->offset;
11308                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11309                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11310                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11311                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11312                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11313                                 if (ndr->offset > ndr->relative_highest_offset) {
11314                                         ndr->relative_highest_offset = ndr->offset;
11315                                 }
11316                                 ndr->offset = _relative_save_offset;
11317                         }
11318                         ndr->flags = _flags_save_string;
11319                 }
11320                 {
11321                         uint32_t _flags_save_string = ndr->flags;
11322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11323                         if (r->config_file) {
11324                                 uint32_t _relative_save_offset;
11325                                 _relative_save_offset = ndr->offset;
11326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11327                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11328                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11331                                 if (ndr->offset > ndr->relative_highest_offset) {
11332                                         ndr->relative_highest_offset = ndr->offset;
11333                                 }
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->help_file) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11345                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11349                                 if (ndr->offset > ndr->relative_highest_offset) {
11350                                         ndr->relative_highest_offset = ndr->offset;
11351                                 }
11352                                 ndr->offset = _relative_save_offset;
11353                         }
11354                         ndr->flags = _flags_save_string;
11355                 }
11356                 {
11357                         uint32_t _flags_save_string_array = ndr->flags;
11358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11359                         if (r->dependent_files) {
11360                                 uint32_t _relative_save_offset;
11361                                 _relative_save_offset = ndr->offset;
11362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11363                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11364                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11365                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11367                                 if (ndr->offset > ndr->relative_highest_offset) {
11368                                         ndr->relative_highest_offset = ndr->offset;
11369                                 }
11370                                 ndr->offset = _relative_save_offset;
11371                         }
11372                         ndr->flags = _flags_save_string_array;
11373                 }
11374                 {
11375                         uint32_t _flags_save_string = ndr->flags;
11376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11377                         if (r->monitor_name) {
11378                                 uint32_t _relative_save_offset;
11379                                 _relative_save_offset = ndr->offset;
11380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11381                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11382                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11385                                 if (ndr->offset > ndr->relative_highest_offset) {
11386                                         ndr->relative_highest_offset = ndr->offset;
11387                                 }
11388                                 ndr->offset = _relative_save_offset;
11389                         }
11390                         ndr->flags = _flags_save_string;
11391                 }
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->default_datatype) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11399                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11403                                 if (ndr->offset > ndr->relative_highest_offset) {
11404                                         ndr->relative_highest_offset = ndr->offset;
11405                                 }
11406                                 ndr->offset = _relative_save_offset;
11407                         }
11408                         ndr->flags = _flags_save_string;
11409                 }
11410         }
11411         return NDR_ERR_SUCCESS;
11412 }
11413
11414 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11415 {
11416         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11417         ndr->depth++;
11418         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11419         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11420         ndr->depth++;
11421         if (r->driver_name) {
11422                 ndr_print_string(ndr, "driver_name", r->driver_name);
11423         }
11424         ndr->depth--;
11425         ndr_print_ptr(ndr, "architecture", r->architecture);
11426         ndr->depth++;
11427         if (r->architecture) {
11428                 ndr_print_string(ndr, "architecture", r->architecture);
11429         }
11430         ndr->depth--;
11431         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11432         ndr->depth++;
11433         if (r->driver_path) {
11434                 ndr_print_string(ndr, "driver_path", r->driver_path);
11435         }
11436         ndr->depth--;
11437         ndr_print_ptr(ndr, "data_file", r->data_file);
11438         ndr->depth++;
11439         if (r->data_file) {
11440                 ndr_print_string(ndr, "data_file", r->data_file);
11441         }
11442         ndr->depth--;
11443         ndr_print_ptr(ndr, "config_file", r->config_file);
11444         ndr->depth++;
11445         if (r->config_file) {
11446                 ndr_print_string(ndr, "config_file", r->config_file);
11447         }
11448         ndr->depth--;
11449         ndr_print_ptr(ndr, "help_file", r->help_file);
11450         ndr->depth++;
11451         if (r->help_file) {
11452                 ndr_print_string(ndr, "help_file", r->help_file);
11453         }
11454         ndr->depth--;
11455         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11456         ndr->depth++;
11457         if (r->dependent_files) {
11458                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11459         }
11460         ndr->depth--;
11461         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11462         ndr->depth++;
11463         if (r->monitor_name) {
11464                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11465         }
11466         ndr->depth--;
11467         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11468         ndr->depth++;
11469         if (r->default_datatype) {
11470                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11471         }
11472         ndr->depth--;
11473         ndr->depth--;
11474 }
11475
11476 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11477 {
11478         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11479 }
11480
11481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11482 {
11483         if (ndr_flags & NDR_SCALARS) {
11484                 NDR_CHECK(ndr_push_align(ndr, 5));
11485                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11486                 {
11487                         uint32_t _flags_save_string = ndr->flags;
11488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11490                         ndr->flags = _flags_save_string;
11491                 }
11492                 {
11493                         uint32_t _flags_save_string = ndr->flags;
11494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11495                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11496                         ndr->flags = _flags_save_string;
11497                 }
11498                 {
11499                         uint32_t _flags_save_string = ndr->flags;
11500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11502                         ndr->flags = _flags_save_string;
11503                 }
11504                 {
11505                         uint32_t _flags_save_string = ndr->flags;
11506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11508                         ndr->flags = _flags_save_string;
11509                 }
11510                 {
11511                         uint32_t _flags_save_string = ndr->flags;
11512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11520                         ndr->flags = _flags_save_string;
11521                 }
11522                 {
11523                         uint32_t _flags_save_string_array = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11526                         ndr->flags = _flags_save_string_array;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11538                         ndr->flags = _flags_save_string;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string_array = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11544                         ndr->flags = _flags_save_string_array;
11545                 }
11546                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11547         }
11548         if (ndr_flags & NDR_BUFFERS) {
11549                 {
11550                         uint32_t _flags_save_string = ndr->flags;
11551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11552                         if (r->driver_name) {
11553                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11554                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11555                         }
11556                         ndr->flags = _flags_save_string;
11557                 }
11558                 {
11559                         uint32_t _flags_save_string = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         if (r->architecture) {
11562                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11563                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11564                         }
11565                         ndr->flags = _flags_save_string;
11566                 }
11567                 {
11568                         uint32_t _flags_save_string = ndr->flags;
11569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11570                         if (r->driver_path) {
11571                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11572                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11573                         }
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         if (r->data_file) {
11580                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11581                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11582                         }
11583                         ndr->flags = _flags_save_string;
11584                 }
11585                 {
11586                         uint32_t _flags_save_string = ndr->flags;
11587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11588                         if (r->config_file) {
11589                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11590                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11591                         }
11592                         ndr->flags = _flags_save_string;
11593                 }
11594                 {
11595                         uint32_t _flags_save_string = ndr->flags;
11596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11597                         if (r->help_file) {
11598                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11599                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11600                         }
11601                         ndr->flags = _flags_save_string;
11602                 }
11603                 {
11604                         uint32_t _flags_save_string_array = ndr->flags;
11605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11606                         if (r->dependent_files) {
11607                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11608                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11609                         }
11610                         ndr->flags = _flags_save_string_array;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         if (r->monitor_name) {
11616                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11617                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11618                         }
11619                         ndr->flags = _flags_save_string;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->default_datatype) {
11625                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11626                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11627                         }
11628                         ndr->flags = _flags_save_string;
11629                 }
11630                 {
11631                         uint32_t _flags_save_string_array = ndr->flags;
11632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11633                         if (r->previous_names) {
11634                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11635                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11636                         }
11637                         ndr->flags = _flags_save_string_array;
11638                 }
11639         }
11640         return NDR_ERR_SUCCESS;
11641 }
11642
11643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11644 {
11645         uint32_t _ptr_driver_name;
11646         TALLOC_CTX *_mem_save_driver_name_0;
11647         uint32_t _ptr_architecture;
11648         TALLOC_CTX *_mem_save_architecture_0;
11649         uint32_t _ptr_driver_path;
11650         TALLOC_CTX *_mem_save_driver_path_0;
11651         uint32_t _ptr_data_file;
11652         TALLOC_CTX *_mem_save_data_file_0;
11653         uint32_t _ptr_config_file;
11654         TALLOC_CTX *_mem_save_config_file_0;
11655         uint32_t _ptr_help_file;
11656         TALLOC_CTX *_mem_save_help_file_0;
11657         uint32_t _ptr_dependent_files;
11658         TALLOC_CTX *_mem_save_dependent_files_0;
11659         uint32_t _ptr_monitor_name;
11660         TALLOC_CTX *_mem_save_monitor_name_0;
11661         uint32_t _ptr_default_datatype;
11662         TALLOC_CTX *_mem_save_default_datatype_0;
11663         uint32_t _ptr_previous_names;
11664         TALLOC_CTX *_mem_save_previous_names_0;
11665         if (ndr_flags & NDR_SCALARS) {
11666                 NDR_CHECK(ndr_pull_align(ndr, 5));
11667                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11668                 {
11669                         uint32_t _flags_save_string = ndr->flags;
11670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11672                         if (_ptr_driver_name) {
11673                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11675                         } else {
11676                                 r->driver_name = NULL;
11677                         }
11678                         ndr->flags = _flags_save_string;
11679                 }
11680                 {
11681                         uint32_t _flags_save_string = ndr->flags;
11682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11684                         if (_ptr_architecture) {
11685                                 NDR_PULL_ALLOC(ndr, r->architecture);
11686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11687                         } else {
11688                                 r->architecture = NULL;
11689                         }
11690                         ndr->flags = _flags_save_string;
11691                 }
11692                 {
11693                         uint32_t _flags_save_string = ndr->flags;
11694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11696                         if (_ptr_driver_path) {
11697                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11699                         } else {
11700                                 r->driver_path = NULL;
11701                         }
11702                         ndr->flags = _flags_save_string;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11708                         if (_ptr_data_file) {
11709                                 NDR_PULL_ALLOC(ndr, r->data_file);
11710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11711                         } else {
11712                                 r->data_file = NULL;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11720                         if (_ptr_config_file) {
11721                                 NDR_PULL_ALLOC(ndr, r->config_file);
11722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11723                         } else {
11724                                 r->config_file = NULL;
11725                         }
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11732                         if (_ptr_help_file) {
11733                                 NDR_PULL_ALLOC(ndr, r->help_file);
11734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11735                         } else {
11736                                 r->help_file = NULL;
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string_array = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11744                         if (_ptr_dependent_files) {
11745                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11747                         } else {
11748                                 r->dependent_files = NULL;
11749                         }
11750                         ndr->flags = _flags_save_string_array;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11756                         if (_ptr_monitor_name) {
11757                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11759                         } else {
11760                                 r->monitor_name = NULL;
11761                         }
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11768                         if (_ptr_default_datatype) {
11769                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11771                         } else {
11772                                 r->default_datatype = NULL;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string_array = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11780                         if (_ptr_previous_names) {
11781                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11783                         } else {
11784                                 r->previous_names = NULL;
11785                         }
11786                         ndr->flags = _flags_save_string_array;
11787                 }
11788                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11789         }
11790         if (ndr_flags & NDR_BUFFERS) {
11791                 {
11792                         uint32_t _flags_save_string = ndr->flags;
11793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11794                         if (r->driver_name) {
11795                                 uint32_t _relative_save_offset;
11796                                 _relative_save_offset = ndr->offset;
11797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11798                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11799                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11802                                 if (ndr->offset > ndr->relative_highest_offset) {
11803                                         ndr->relative_highest_offset = ndr->offset;
11804                                 }
11805                                 ndr->offset = _relative_save_offset;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         if (r->architecture) {
11813                                 uint32_t _relative_save_offset;
11814                                 _relative_save_offset = ndr->offset;
11815                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11816                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11817                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11818                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11819                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11820                                 if (ndr->offset > ndr->relative_highest_offset) {
11821                                         ndr->relative_highest_offset = ndr->offset;
11822                                 }
11823                                 ndr->offset = _relative_save_offset;
11824                         }
11825                         ndr->flags = _flags_save_string;
11826                 }
11827                 {
11828                         uint32_t _flags_save_string = ndr->flags;
11829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11830                         if (r->driver_path) {
11831                                 uint32_t _relative_save_offset;
11832                                 _relative_save_offset = ndr->offset;
11833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11834                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11835                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11838                                 if (ndr->offset > ndr->relative_highest_offset) {
11839                                         ndr->relative_highest_offset = ndr->offset;
11840                                 }
11841                                 ndr->offset = _relative_save_offset;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         if (r->data_file) {
11849                                 uint32_t _relative_save_offset;
11850                                 _relative_save_offset = ndr->offset;
11851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11852                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11853                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11856                                 if (ndr->offset > ndr->relative_highest_offset) {
11857                                         ndr->relative_highest_offset = ndr->offset;
11858                                 }
11859                                 ndr->offset = _relative_save_offset;
11860                         }
11861                         ndr->flags = _flags_save_string;
11862                 }
11863                 {
11864                         uint32_t _flags_save_string = ndr->flags;
11865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11866                         if (r->config_file) {
11867                                 uint32_t _relative_save_offset;
11868                                 _relative_save_offset = ndr->offset;
11869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11870                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11871                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11874                                 if (ndr->offset > ndr->relative_highest_offset) {
11875                                         ndr->relative_highest_offset = ndr->offset;
11876                                 }
11877                                 ndr->offset = _relative_save_offset;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         if (r->help_file) {
11885                                 uint32_t _relative_save_offset;
11886                                 _relative_save_offset = ndr->offset;
11887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11888                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11889                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11892                                 if (ndr->offset > ndr->relative_highest_offset) {
11893                                         ndr->relative_highest_offset = ndr->offset;
11894                                 }
11895                                 ndr->offset = _relative_save_offset;
11896                         }
11897                         ndr->flags = _flags_save_string;
11898                 }
11899                 {
11900                         uint32_t _flags_save_string_array = ndr->flags;
11901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11902                         if (r->dependent_files) {
11903                                 uint32_t _relative_save_offset;
11904                                 _relative_save_offset = ndr->offset;
11905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11906                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11907                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11908                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11910                                 if (ndr->offset > ndr->relative_highest_offset) {
11911                                         ndr->relative_highest_offset = ndr->offset;
11912                                 }
11913                                 ndr->offset = _relative_save_offset;
11914                         }
11915                         ndr->flags = _flags_save_string_array;
11916                 }
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         if (r->monitor_name) {
11921                                 uint32_t _relative_save_offset;
11922                                 _relative_save_offset = ndr->offset;
11923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11924                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11925                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11928                                 if (ndr->offset > ndr->relative_highest_offset) {
11929                                         ndr->relative_highest_offset = ndr->offset;
11930                                 }
11931                                 ndr->offset = _relative_save_offset;
11932                         }
11933                         ndr->flags = _flags_save_string;
11934                 }
11935                 {
11936                         uint32_t _flags_save_string = ndr->flags;
11937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11938                         if (r->default_datatype) {
11939                                 uint32_t _relative_save_offset;
11940                                 _relative_save_offset = ndr->offset;
11941                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11942                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11943                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11944                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11945                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11946                                 if (ndr->offset > ndr->relative_highest_offset) {
11947                                         ndr->relative_highest_offset = ndr->offset;
11948                                 }
11949                                 ndr->offset = _relative_save_offset;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string_array = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         if (r->previous_names) {
11957                                 uint32_t _relative_save_offset;
11958                                 _relative_save_offset = ndr->offset;
11959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11960                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11961                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11962                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11964                                 if (ndr->offset > ndr->relative_highest_offset) {
11965                                         ndr->relative_highest_offset = ndr->offset;
11966                                 }
11967                                 ndr->offset = _relative_save_offset;
11968                         }
11969                         ndr->flags = _flags_save_string_array;
11970                 }
11971         }
11972         return NDR_ERR_SUCCESS;
11973 }
11974
11975 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11976 {
11977         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11978         ndr->depth++;
11979         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11980         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11981         ndr->depth++;
11982         if (r->driver_name) {
11983                 ndr_print_string(ndr, "driver_name", r->driver_name);
11984         }
11985         ndr->depth--;
11986         ndr_print_ptr(ndr, "architecture", r->architecture);
11987         ndr->depth++;
11988         if (r->architecture) {
11989                 ndr_print_string(ndr, "architecture", r->architecture);
11990         }
11991         ndr->depth--;
11992         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11993         ndr->depth++;
11994         if (r->driver_path) {
11995                 ndr_print_string(ndr, "driver_path", r->driver_path);
11996         }
11997         ndr->depth--;
11998         ndr_print_ptr(ndr, "data_file", r->data_file);
11999         ndr->depth++;
12000         if (r->data_file) {
12001                 ndr_print_string(ndr, "data_file", r->data_file);
12002         }
12003         ndr->depth--;
12004         ndr_print_ptr(ndr, "config_file", r->config_file);
12005         ndr->depth++;
12006         if (r->config_file) {
12007                 ndr_print_string(ndr, "config_file", r->config_file);
12008         }
12009         ndr->depth--;
12010         ndr_print_ptr(ndr, "help_file", r->help_file);
12011         ndr->depth++;
12012         if (r->help_file) {
12013                 ndr_print_string(ndr, "help_file", r->help_file);
12014         }
12015         ndr->depth--;
12016         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12017         ndr->depth++;
12018         if (r->dependent_files) {
12019                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12020         }
12021         ndr->depth--;
12022         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12023         ndr->depth++;
12024         if (r->monitor_name) {
12025                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12026         }
12027         ndr->depth--;
12028         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12029         ndr->depth++;
12030         if (r->default_datatype) {
12031                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12032         }
12033         ndr->depth--;
12034         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12035         ndr->depth++;
12036         if (r->previous_names) {
12037                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12038         }
12039         ndr->depth--;
12040         ndr->depth--;
12041 }
12042
12043 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12044 {
12045         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12046 }
12047
12048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12049 {
12050         if (ndr_flags & NDR_SCALARS) {
12051                 NDR_CHECK(ndr_push_align(ndr, 5));
12052                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12053                 {
12054                         uint32_t _flags_save_string = ndr->flags;
12055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12057                         ndr->flags = _flags_save_string;
12058                 }
12059                 {
12060                         uint32_t _flags_save_string = ndr->flags;
12061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12063                         ndr->flags = _flags_save_string;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12075                         ndr->flags = _flags_save_string;
12076                 }
12077                 {
12078                         uint32_t _flags_save_string = ndr->flags;
12079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12081                         ndr->flags = _flags_save_string;
12082                 }
12083                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12086                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12087         }
12088         if (ndr_flags & NDR_BUFFERS) {
12089                 {
12090                         uint32_t _flags_save_string = ndr->flags;
12091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12092                         if (r->driver_name) {
12093                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12094                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12095                         }
12096                         ndr->flags = _flags_save_string;
12097                 }
12098                 {
12099                         uint32_t _flags_save_string = ndr->flags;
12100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12101                         if (r->architecture) {
12102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12104                         }
12105                         ndr->flags = _flags_save_string;
12106                 }
12107                 {
12108                         uint32_t _flags_save_string = ndr->flags;
12109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12110                         if (r->driver_path) {
12111                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12112                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12113                         }
12114                         ndr->flags = _flags_save_string;
12115                 }
12116                 {
12117                         uint32_t _flags_save_string = ndr->flags;
12118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12119                         if (r->data_file) {
12120                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12121                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12122                         }
12123                         ndr->flags = _flags_save_string;
12124                 }
12125                 {
12126                         uint32_t _flags_save_string = ndr->flags;
12127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12128                         if (r->config_file) {
12129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12131                         }
12132                         ndr->flags = _flags_save_string;
12133                 }
12134         }
12135         return NDR_ERR_SUCCESS;
12136 }
12137
12138 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12139 {
12140         uint32_t _ptr_driver_name;
12141         TALLOC_CTX *_mem_save_driver_name_0;
12142         uint32_t _ptr_architecture;
12143         TALLOC_CTX *_mem_save_architecture_0;
12144         uint32_t _ptr_driver_path;
12145         TALLOC_CTX *_mem_save_driver_path_0;
12146         uint32_t _ptr_data_file;
12147         TALLOC_CTX *_mem_save_data_file_0;
12148         uint32_t _ptr_config_file;
12149         TALLOC_CTX *_mem_save_config_file_0;
12150         if (ndr_flags & NDR_SCALARS) {
12151                 NDR_CHECK(ndr_pull_align(ndr, 5));
12152                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12153                 {
12154                         uint32_t _flags_save_string = ndr->flags;
12155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12156                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12157                         if (_ptr_driver_name) {
12158                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12159                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12160                         } else {
12161                                 r->driver_name = NULL;
12162                         }
12163                         ndr->flags = _flags_save_string;
12164                 }
12165                 {
12166                         uint32_t _flags_save_string = ndr->flags;
12167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12169                         if (_ptr_architecture) {
12170                                 NDR_PULL_ALLOC(ndr, r->architecture);
12171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12172                         } else {
12173                                 r->architecture = NULL;
12174                         }
12175                         ndr->flags = _flags_save_string;
12176                 }
12177                 {
12178                         uint32_t _flags_save_string = ndr->flags;
12179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12181                         if (_ptr_driver_path) {
12182                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12184                         } else {
12185                                 r->driver_path = NULL;
12186                         }
12187                         ndr->flags = _flags_save_string;
12188                 }
12189                 {
12190                         uint32_t _flags_save_string = ndr->flags;
12191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12193                         if (_ptr_data_file) {
12194                                 NDR_PULL_ALLOC(ndr, r->data_file);
12195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12196                         } else {
12197                                 r->data_file = NULL;
12198                         }
12199                         ndr->flags = _flags_save_string;
12200                 }
12201                 {
12202                         uint32_t _flags_save_string = ndr->flags;
12203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12205                         if (_ptr_config_file) {
12206                                 NDR_PULL_ALLOC(ndr, r->config_file);
12207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12208                         } else {
12209                                 r->config_file = NULL;
12210                         }
12211                         ndr->flags = _flags_save_string;
12212                 }
12213                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12217         }
12218         if (ndr_flags & NDR_BUFFERS) {
12219                 {
12220                         uint32_t _flags_save_string = ndr->flags;
12221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12222                         if (r->driver_name) {
12223                                 uint32_t _relative_save_offset;
12224                                 _relative_save_offset = ndr->offset;
12225                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12226                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12227                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12228                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12229                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12230                                 if (ndr->offset > ndr->relative_highest_offset) {
12231                                         ndr->relative_highest_offset = ndr->offset;
12232                                 }
12233                                 ndr->offset = _relative_save_offset;
12234                         }
12235                         ndr->flags = _flags_save_string;
12236                 }
12237                 {
12238                         uint32_t _flags_save_string = ndr->flags;
12239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12240                         if (r->architecture) {
12241                                 uint32_t _relative_save_offset;
12242                                 _relative_save_offset = ndr->offset;
12243                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12244                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12246                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12247                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12248                                 if (ndr->offset > ndr->relative_highest_offset) {
12249                                         ndr->relative_highest_offset = ndr->offset;
12250                                 }
12251                                 ndr->offset = _relative_save_offset;
12252                         }
12253                         ndr->flags = _flags_save_string;
12254                 }
12255                 {
12256                         uint32_t _flags_save_string = ndr->flags;
12257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12258                         if (r->driver_path) {
12259                                 uint32_t _relative_save_offset;
12260                                 _relative_save_offset = ndr->offset;
12261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12262                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12266                                 if (ndr->offset > ndr->relative_highest_offset) {
12267                                         ndr->relative_highest_offset = ndr->offset;
12268                                 }
12269                                 ndr->offset = _relative_save_offset;
12270                         }
12271                         ndr->flags = _flags_save_string;
12272                 }
12273                 {
12274                         uint32_t _flags_save_string = ndr->flags;
12275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12276                         if (r->data_file) {
12277                                 uint32_t _relative_save_offset;
12278                                 _relative_save_offset = ndr->offset;
12279                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12280                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12282                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12283                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12284                                 if (ndr->offset > ndr->relative_highest_offset) {
12285                                         ndr->relative_highest_offset = ndr->offset;
12286                                 }
12287                                 ndr->offset = _relative_save_offset;
12288                         }
12289                         ndr->flags = _flags_save_string;
12290                 }
12291                 {
12292                         uint32_t _flags_save_string = ndr->flags;
12293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12294                         if (r->config_file) {
12295                                 uint32_t _relative_save_offset;
12296                                 _relative_save_offset = ndr->offset;
12297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12298                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12302                                 if (ndr->offset > ndr->relative_highest_offset) {
12303                                         ndr->relative_highest_offset = ndr->offset;
12304                                 }
12305                                 ndr->offset = _relative_save_offset;
12306                         }
12307                         ndr->flags = _flags_save_string;
12308                 }
12309         }
12310         return NDR_ERR_SUCCESS;
12311 }
12312
12313 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12314 {
12315         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12316         ndr->depth++;
12317         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12318         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12319         ndr->depth++;
12320         if (r->driver_name) {
12321                 ndr_print_string(ndr, "driver_name", r->driver_name);
12322         }
12323         ndr->depth--;
12324         ndr_print_ptr(ndr, "architecture", r->architecture);
12325         ndr->depth++;
12326         if (r->architecture) {
12327                 ndr_print_string(ndr, "architecture", r->architecture);
12328         }
12329         ndr->depth--;
12330         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12331         ndr->depth++;
12332         if (r->driver_path) {
12333                 ndr_print_string(ndr, "driver_path", r->driver_path);
12334         }
12335         ndr->depth--;
12336         ndr_print_ptr(ndr, "data_file", r->data_file);
12337         ndr->depth++;
12338         if (r->data_file) {
12339                 ndr_print_string(ndr, "data_file", r->data_file);
12340         }
12341         ndr->depth--;
12342         ndr_print_ptr(ndr, "config_file", r->config_file);
12343         ndr->depth++;
12344         if (r->config_file) {
12345                 ndr_print_string(ndr, "config_file", r->config_file);
12346         }
12347         ndr->depth--;
12348         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12349         ndr_print_uint32(ndr, "config_version", r->config_version);
12350         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12351         ndr->depth--;
12352 }
12353
12354 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12355 {
12356         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12357 }
12358
12359 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12360 {
12361         if (ndr_flags & NDR_SCALARS) {
12362                 NDR_CHECK(ndr_push_align(ndr, 8));
12363                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12364                 {
12365                         uint32_t _flags_save_string = ndr->flags;
12366                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12367                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12368                         ndr->flags = _flags_save_string;
12369                 }
12370                 {
12371                         uint32_t _flags_save_string = ndr->flags;
12372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12373                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12374                         ndr->flags = _flags_save_string;
12375                 }
12376                 {
12377                         uint32_t _flags_save_string = ndr->flags;
12378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12379                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12380                         ndr->flags = _flags_save_string;
12381                 }
12382                 {
12383                         uint32_t _flags_save_string = ndr->flags;
12384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12385                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12386                         ndr->flags = _flags_save_string;
12387                 }
12388                 {
12389                         uint32_t _flags_save_string = ndr->flags;
12390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12391                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12392                         ndr->flags = _flags_save_string;
12393                 }
12394                 {
12395                         uint32_t _flags_save_string = ndr->flags;
12396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12397                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12398                         ndr->flags = _flags_save_string;
12399                 }
12400                 {
12401                         uint32_t _flags_save_string_array = ndr->flags;
12402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12403                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12404                         ndr->flags = _flags_save_string_array;
12405                 }
12406                 {
12407                         uint32_t _flags_save_string = ndr->flags;
12408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12409                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12410                         ndr->flags = _flags_save_string;
12411                 }
12412                 {
12413                         uint32_t _flags_save_string = ndr->flags;
12414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12415                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12416                         ndr->flags = _flags_save_string;
12417                 }
12418                 {
12419                         uint32_t _flags_save_string_array = ndr->flags;
12420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12421                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12422                         ndr->flags = _flags_save_string_array;
12423                 }
12424                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12425                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12426                 {
12427                         uint32_t _flags_save_string = ndr->flags;
12428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12429                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12436                         ndr->flags = _flags_save_string;
12437                 }
12438                 {
12439                         uint32_t _flags_save_string = ndr->flags;
12440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12442                         ndr->flags = _flags_save_string;
12443                 }
12444                 {
12445                         uint32_t _flags_save_string = ndr->flags;
12446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12447                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12448                         ndr->flags = _flags_save_string;
12449                 }
12450                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12451         }
12452         if (ndr_flags & NDR_BUFFERS) {
12453                 {
12454                         uint32_t _flags_save_string = ndr->flags;
12455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12456                         if (r->driver_name) {
12457                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12458                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12459                         }
12460                         ndr->flags = _flags_save_string;
12461                 }
12462                 {
12463                         uint32_t _flags_save_string = ndr->flags;
12464                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12465                         if (r->architecture) {
12466                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12467                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12468                         }
12469                         ndr->flags = _flags_save_string;
12470                 }
12471                 {
12472                         uint32_t _flags_save_string = ndr->flags;
12473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12474                         if (r->driver_path) {
12475                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12476                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12477                         }
12478                         ndr->flags = _flags_save_string;
12479                 }
12480                 {
12481                         uint32_t _flags_save_string = ndr->flags;
12482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12483                         if (r->data_file) {
12484                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12485                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12486                         }
12487                         ndr->flags = _flags_save_string;
12488                 }
12489                 {
12490                         uint32_t _flags_save_string = ndr->flags;
12491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12492                         if (r->config_file) {
12493                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12494                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12495                         }
12496                         ndr->flags = _flags_save_string;
12497                 }
12498                 {
12499                         uint32_t _flags_save_string = ndr->flags;
12500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12501                         if (r->help_file) {
12502                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12503                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12504                         }
12505                         ndr->flags = _flags_save_string;
12506                 }
12507                 {
12508                         uint32_t _flags_save_string_array = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         if (r->dependent_files) {
12511                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12512                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12513                         }
12514                         ndr->flags = _flags_save_string_array;
12515                 }
12516                 {
12517                         uint32_t _flags_save_string = ndr->flags;
12518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12519                         if (r->monitor_name) {
12520                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12521                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12522                         }
12523                         ndr->flags = _flags_save_string;
12524                 }
12525                 {
12526                         uint32_t _flags_save_string = ndr->flags;
12527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12528                         if (r->default_datatype) {
12529                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12530                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12531                         }
12532                         ndr->flags = _flags_save_string;
12533                 }
12534                 {
12535                         uint32_t _flags_save_string_array = ndr->flags;
12536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12537                         if (r->previous_names) {
12538                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12539                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12540                         }
12541                         ndr->flags = _flags_save_string_array;
12542                 }
12543                 {
12544                         uint32_t _flags_save_string = ndr->flags;
12545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12546                         if (r->manufacturer_name) {
12547                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12548                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12549                         }
12550                         ndr->flags = _flags_save_string;
12551                 }
12552                 {
12553                         uint32_t _flags_save_string = ndr->flags;
12554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12555                         if (r->manufacturer_url) {
12556                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12557                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12558                         }
12559                         ndr->flags = _flags_save_string;
12560                 }
12561                 {
12562                         uint32_t _flags_save_string = ndr->flags;
12563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12564                         if (r->hardware_id) {
12565                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12566                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12567                         }
12568                         ndr->flags = _flags_save_string;
12569                 }
12570                 {
12571                         uint32_t _flags_save_string = ndr->flags;
12572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12573                         if (r->provider) {
12574                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12575                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12576                         }
12577                         ndr->flags = _flags_save_string;
12578                 }
12579         }
12580         return NDR_ERR_SUCCESS;
12581 }
12582
12583 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12584 {
12585         uint32_t _ptr_driver_name;
12586         TALLOC_CTX *_mem_save_driver_name_0;
12587         uint32_t _ptr_architecture;
12588         TALLOC_CTX *_mem_save_architecture_0;
12589         uint32_t _ptr_driver_path;
12590         TALLOC_CTX *_mem_save_driver_path_0;
12591         uint32_t _ptr_data_file;
12592         TALLOC_CTX *_mem_save_data_file_0;
12593         uint32_t _ptr_config_file;
12594         TALLOC_CTX *_mem_save_config_file_0;
12595         uint32_t _ptr_help_file;
12596         TALLOC_CTX *_mem_save_help_file_0;
12597         uint32_t _ptr_dependent_files;
12598         TALLOC_CTX *_mem_save_dependent_files_0;
12599         uint32_t _ptr_monitor_name;
12600         TALLOC_CTX *_mem_save_monitor_name_0;
12601         uint32_t _ptr_default_datatype;
12602         TALLOC_CTX *_mem_save_default_datatype_0;
12603         uint32_t _ptr_previous_names;
12604         TALLOC_CTX *_mem_save_previous_names_0;
12605         uint32_t _ptr_manufacturer_name;
12606         TALLOC_CTX *_mem_save_manufacturer_name_0;
12607         uint32_t _ptr_manufacturer_url;
12608         TALLOC_CTX *_mem_save_manufacturer_url_0;
12609         uint32_t _ptr_hardware_id;
12610         TALLOC_CTX *_mem_save_hardware_id_0;
12611         uint32_t _ptr_provider;
12612         TALLOC_CTX *_mem_save_provider_0;
12613         if (ndr_flags & NDR_SCALARS) {
12614                 NDR_CHECK(ndr_pull_align(ndr, 8));
12615                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12616                 {
12617                         uint32_t _flags_save_string = ndr->flags;
12618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12619                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12620                         if (_ptr_driver_name) {
12621                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12622                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12623                         } else {
12624                                 r->driver_name = NULL;
12625                         }
12626                         ndr->flags = _flags_save_string;
12627                 }
12628                 {
12629                         uint32_t _flags_save_string = ndr->flags;
12630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12631                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12632                         if (_ptr_architecture) {
12633                                 NDR_PULL_ALLOC(ndr, r->architecture);
12634                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12635                         } else {
12636                                 r->architecture = NULL;
12637                         }
12638                         ndr->flags = _flags_save_string;
12639                 }
12640                 {
12641                         uint32_t _flags_save_string = ndr->flags;
12642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12643                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12644                         if (_ptr_driver_path) {
12645                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12646                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12647                         } else {
12648                                 r->driver_path = NULL;
12649                         }
12650                         ndr->flags = _flags_save_string;
12651                 }
12652                 {
12653                         uint32_t _flags_save_string = ndr->flags;
12654                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12655                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12656                         if (_ptr_data_file) {
12657                                 NDR_PULL_ALLOC(ndr, r->data_file);
12658                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12659                         } else {
12660                                 r->data_file = NULL;
12661                         }
12662                         ndr->flags = _flags_save_string;
12663                 }
12664                 {
12665                         uint32_t _flags_save_string = ndr->flags;
12666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12667                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12668                         if (_ptr_config_file) {
12669                                 NDR_PULL_ALLOC(ndr, r->config_file);
12670                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12671                         } else {
12672                                 r->config_file = NULL;
12673                         }
12674                         ndr->flags = _flags_save_string;
12675                 }
12676                 {
12677                         uint32_t _flags_save_string = ndr->flags;
12678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12679                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12680                         if (_ptr_help_file) {
12681                                 NDR_PULL_ALLOC(ndr, r->help_file);
12682                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12683                         } else {
12684                                 r->help_file = NULL;
12685                         }
12686                         ndr->flags = _flags_save_string;
12687                 }
12688                 {
12689                         uint32_t _flags_save_string_array = ndr->flags;
12690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12692                         if (_ptr_dependent_files) {
12693                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12695                         } else {
12696                                 r->dependent_files = NULL;
12697                         }
12698                         ndr->flags = _flags_save_string_array;
12699                 }
12700                 {
12701                         uint32_t _flags_save_string = ndr->flags;
12702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12704                         if (_ptr_monitor_name) {
12705                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12707                         } else {
12708                                 r->monitor_name = NULL;
12709                         }
12710                         ndr->flags = _flags_save_string;
12711                 }
12712                 {
12713                         uint32_t _flags_save_string = ndr->flags;
12714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12716                         if (_ptr_default_datatype) {
12717                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12719                         } else {
12720                                 r->default_datatype = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
12724                 {
12725                         uint32_t _flags_save_string_array = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12728                         if (_ptr_previous_names) {
12729                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12731                         } else {
12732                                 r->previous_names = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string_array;
12735                 }
12736                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12737                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12738                 {
12739                         uint32_t _flags_save_string = ndr->flags;
12740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12742                         if (_ptr_manufacturer_name) {
12743                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12745                         } else {
12746                                 r->manufacturer_name = NULL;
12747                         }
12748                         ndr->flags = _flags_save_string;
12749                 }
12750                 {
12751                         uint32_t _flags_save_string = ndr->flags;
12752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12754                         if (_ptr_manufacturer_url) {
12755                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12757                         } else {
12758                                 r->manufacturer_url = NULL;
12759                         }
12760                         ndr->flags = _flags_save_string;
12761                 }
12762                 {
12763                         uint32_t _flags_save_string = ndr->flags;
12764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12766                         if (_ptr_hardware_id) {
12767                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12769                         } else {
12770                                 r->hardware_id = NULL;
12771                         }
12772                         ndr->flags = _flags_save_string;
12773                 }
12774                 {
12775                         uint32_t _flags_save_string = ndr->flags;
12776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12778                         if (_ptr_provider) {
12779                                 NDR_PULL_ALLOC(ndr, r->provider);
12780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12781                         } else {
12782                                 r->provider = NULL;
12783                         }
12784                         ndr->flags = _flags_save_string;
12785                 }
12786                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12787         }
12788         if (ndr_flags & NDR_BUFFERS) {
12789                 {
12790                         uint32_t _flags_save_string = ndr->flags;
12791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12792                         if (r->driver_name) {
12793                                 uint32_t _relative_save_offset;
12794                                 _relative_save_offset = ndr->offset;
12795                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12796                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12797                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12798                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12799                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12800                                 if (ndr->offset > ndr->relative_highest_offset) {
12801                                         ndr->relative_highest_offset = ndr->offset;
12802                                 }
12803                                 ndr->offset = _relative_save_offset;
12804                         }
12805                         ndr->flags = _flags_save_string;
12806                 }
12807                 {
12808                         uint32_t _flags_save_string = ndr->flags;
12809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12810                         if (r->architecture) {
12811                                 uint32_t _relative_save_offset;
12812                                 _relative_save_offset = ndr->offset;
12813                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12814                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12815                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12816                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12817                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12818                                 if (ndr->offset > ndr->relative_highest_offset) {
12819                                         ndr->relative_highest_offset = ndr->offset;
12820                                 }
12821                                 ndr->offset = _relative_save_offset;
12822                         }
12823                         ndr->flags = _flags_save_string;
12824                 }
12825                 {
12826                         uint32_t _flags_save_string = ndr->flags;
12827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12828                         if (r->driver_path) {
12829                                 uint32_t _relative_save_offset;
12830                                 _relative_save_offset = ndr->offset;
12831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12832                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12833                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12836                                 if (ndr->offset > ndr->relative_highest_offset) {
12837                                         ndr->relative_highest_offset = ndr->offset;
12838                                 }
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->data_file) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12850                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12854                                 if (ndr->offset > ndr->relative_highest_offset) {
12855                                         ndr->relative_highest_offset = ndr->offset;
12856                                 }
12857                                 ndr->offset = _relative_save_offset;
12858                         }
12859                         ndr->flags = _flags_save_string;
12860                 }
12861                 {
12862                         uint32_t _flags_save_string = ndr->flags;
12863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12864                         if (r->config_file) {
12865                                 uint32_t _relative_save_offset;
12866                                 _relative_save_offset = ndr->offset;
12867                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12868                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12869                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12870                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12871                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12872                                 if (ndr->offset > ndr->relative_highest_offset) {
12873                                         ndr->relative_highest_offset = ndr->offset;
12874                                 }
12875                                 ndr->offset = _relative_save_offset;
12876                         }
12877                         ndr->flags = _flags_save_string;
12878                 }
12879                 {
12880                         uint32_t _flags_save_string = ndr->flags;
12881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12882                         if (r->help_file) {
12883                                 uint32_t _relative_save_offset;
12884                                 _relative_save_offset = ndr->offset;
12885                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12886                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12887                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12888                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12889                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12890                                 if (ndr->offset > ndr->relative_highest_offset) {
12891                                         ndr->relative_highest_offset = ndr->offset;
12892                                 }
12893                                 ndr->offset = _relative_save_offset;
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string_array = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->dependent_files) {
12901                                 uint32_t _relative_save_offset;
12902                                 _relative_save_offset = ndr->offset;
12903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12904                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12906                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12908                                 if (ndr->offset > ndr->relative_highest_offset) {
12909                                         ndr->relative_highest_offset = ndr->offset;
12910                                 }
12911                                 ndr->offset = _relative_save_offset;
12912                         }
12913                         ndr->flags = _flags_save_string_array;
12914                 }
12915                 {
12916                         uint32_t _flags_save_string = ndr->flags;
12917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12918                         if (r->monitor_name) {
12919                                 uint32_t _relative_save_offset;
12920                                 _relative_save_offset = ndr->offset;
12921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12922                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12923                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12926                                 if (ndr->offset > ndr->relative_highest_offset) {
12927                                         ndr->relative_highest_offset = ndr->offset;
12928                                 }
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->default_datatype) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12940                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12942                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12944                                 if (ndr->offset > ndr->relative_highest_offset) {
12945                                         ndr->relative_highest_offset = ndr->offset;
12946                                 }
12947                                 ndr->offset = _relative_save_offset;
12948                         }
12949                         ndr->flags = _flags_save_string;
12950                 }
12951                 {
12952                         uint32_t _flags_save_string_array = ndr->flags;
12953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12954                         if (r->previous_names) {
12955                                 uint32_t _relative_save_offset;
12956                                 _relative_save_offset = ndr->offset;
12957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12958                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12959                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12960                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12962                                 if (ndr->offset > ndr->relative_highest_offset) {
12963                                         ndr->relative_highest_offset = ndr->offset;
12964                                 }
12965                                 ndr->offset = _relative_save_offset;
12966                         }
12967                         ndr->flags = _flags_save_string_array;
12968                 }
12969                 {
12970                         uint32_t _flags_save_string = ndr->flags;
12971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12972                         if (r->manufacturer_name) {
12973                                 uint32_t _relative_save_offset;
12974                                 _relative_save_offset = ndr->offset;
12975                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12976                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12977                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12978                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12979                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12980                                 if (ndr->offset > ndr->relative_highest_offset) {
12981                                         ndr->relative_highest_offset = ndr->offset;
12982                                 }
12983                                 ndr->offset = _relative_save_offset;
12984                         }
12985                         ndr->flags = _flags_save_string;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->manufacturer_url) {
12991                                 uint32_t _relative_save_offset;
12992                                 _relative_save_offset = ndr->offset;
12993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12994                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12995                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12998                                 if (ndr->offset > ndr->relative_highest_offset) {
12999                                         ndr->relative_highest_offset = ndr->offset;
13000                                 }
13001                                 ndr->offset = _relative_save_offset;
13002                         }
13003                         ndr->flags = _flags_save_string;
13004                 }
13005                 {
13006                         uint32_t _flags_save_string = ndr->flags;
13007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13008                         if (r->hardware_id) {
13009                                 uint32_t _relative_save_offset;
13010                                 _relative_save_offset = ndr->offset;
13011                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13012                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13013                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13014                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13015                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13016                                 if (ndr->offset > ndr->relative_highest_offset) {
13017                                         ndr->relative_highest_offset = ndr->offset;
13018                                 }
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->provider) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13030                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13034                                 if (ndr->offset > ndr->relative_highest_offset) {
13035                                         ndr->relative_highest_offset = ndr->offset;
13036                                 }
13037                                 ndr->offset = _relative_save_offset;
13038                         }
13039                         ndr->flags = _flags_save_string;
13040                 }
13041         }
13042         return NDR_ERR_SUCCESS;
13043 }
13044
13045 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13046 {
13047         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13048         ndr->depth++;
13049         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13050         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13051         ndr->depth++;
13052         if (r->driver_name) {
13053                 ndr_print_string(ndr, "driver_name", r->driver_name);
13054         }
13055         ndr->depth--;
13056         ndr_print_ptr(ndr, "architecture", r->architecture);
13057         ndr->depth++;
13058         if (r->architecture) {
13059                 ndr_print_string(ndr, "architecture", r->architecture);
13060         }
13061         ndr->depth--;
13062         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13063         ndr->depth++;
13064         if (r->driver_path) {
13065                 ndr_print_string(ndr, "driver_path", r->driver_path);
13066         }
13067         ndr->depth--;
13068         ndr_print_ptr(ndr, "data_file", r->data_file);
13069         ndr->depth++;
13070         if (r->data_file) {
13071                 ndr_print_string(ndr, "data_file", r->data_file);
13072         }
13073         ndr->depth--;
13074         ndr_print_ptr(ndr, "config_file", r->config_file);
13075         ndr->depth++;
13076         if (r->config_file) {
13077                 ndr_print_string(ndr, "config_file", r->config_file);
13078         }
13079         ndr->depth--;
13080         ndr_print_ptr(ndr, "help_file", r->help_file);
13081         ndr->depth++;
13082         if (r->help_file) {
13083                 ndr_print_string(ndr, "help_file", r->help_file);
13084         }
13085         ndr->depth--;
13086         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13087         ndr->depth++;
13088         if (r->dependent_files) {
13089                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13090         }
13091         ndr->depth--;
13092         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13093         ndr->depth++;
13094         if (r->monitor_name) {
13095                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13096         }
13097         ndr->depth--;
13098         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13099         ndr->depth++;
13100         if (r->default_datatype) {
13101                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13102         }
13103         ndr->depth--;
13104         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13105         ndr->depth++;
13106         if (r->previous_names) {
13107                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13108         }
13109         ndr->depth--;
13110         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13111         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13112         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13113         ndr->depth++;
13114         if (r->manufacturer_name) {
13115                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13116         }
13117         ndr->depth--;
13118         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13119         ndr->depth++;
13120         if (r->manufacturer_url) {
13121                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13122         }
13123         ndr->depth--;
13124         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13125         ndr->depth++;
13126         if (r->hardware_id) {
13127                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13128         }
13129         ndr->depth--;
13130         ndr_print_ptr(ndr, "provider", r->provider);
13131         ndr->depth++;
13132         if (r->provider) {
13133                 ndr_print_string(ndr, "provider", r->provider);
13134         }
13135         ndr->depth--;
13136         ndr->depth--;
13137 }
13138
13139 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13140 {
13141         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13142 }
13143
13144 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13145 {
13146         if (ndr_flags & NDR_SCALARS) {
13147                 NDR_CHECK(ndr_push_align(ndr, 5));
13148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13149                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13150                 {
13151                         uint32_t _flags_save_string = ndr->flags;
13152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13154                         ndr->flags = _flags_save_string;
13155                 }
13156                 {
13157                         uint32_t _flags_save_string = ndr->flags;
13158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13159                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13160                         ndr->flags = _flags_save_string;
13161                 }
13162                 {
13163                         uint32_t _flags_save_string = ndr->flags;
13164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13165                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13166                         ndr->flags = _flags_save_string;
13167                 }
13168                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13169         }
13170         if (ndr_flags & NDR_BUFFERS) {
13171                 {
13172                         uint32_t _flags_save_string = ndr->flags;
13173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13174                         if (r->driver_name) {
13175                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13176                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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                         if (r->inf_name) {
13184                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_name));
13185                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13186                         }
13187                         ndr->flags = _flags_save_string;
13188                 }
13189                 {
13190                         uint32_t _flags_save_string = ndr->flags;
13191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13192                         if (r->install_source_root) {
13193                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->install_source_root));
13194                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13195                         }
13196                         ndr->flags = _flags_save_string;
13197                 }
13198         }
13199         return NDR_ERR_SUCCESS;
13200 }
13201
13202 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13203 {
13204         uint32_t _ptr_driver_name;
13205         TALLOC_CTX *_mem_save_driver_name_0;
13206         uint32_t _ptr_inf_name;
13207         TALLOC_CTX *_mem_save_inf_name_0;
13208         uint32_t _ptr_install_source_root;
13209         TALLOC_CTX *_mem_save_install_source_root_0;
13210         if (ndr_flags & NDR_SCALARS) {
13211                 NDR_CHECK(ndr_pull_align(ndr, 5));
13212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13213                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13214                 {
13215                         uint32_t _flags_save_string = ndr->flags;
13216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13217                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13218                         if (_ptr_driver_name) {
13219                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13220                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13221                         } else {
13222                                 r->driver_name = NULL;
13223                         }
13224                         ndr->flags = _flags_save_string;
13225                 }
13226                 {
13227                         uint32_t _flags_save_string = ndr->flags;
13228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13229                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13230                         if (_ptr_inf_name) {
13231                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13232                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13233                         } else {
13234                                 r->inf_name = NULL;
13235                         }
13236                         ndr->flags = _flags_save_string;
13237                 }
13238                 {
13239                         uint32_t _flags_save_string = ndr->flags;
13240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13241                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13242                         if (_ptr_install_source_root) {
13243                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13244                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13245                         } else {
13246                                 r->install_source_root = NULL;
13247                         }
13248                         ndr->flags = _flags_save_string;
13249                 }
13250                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13251         }
13252         if (ndr_flags & NDR_BUFFERS) {
13253                 {
13254                         uint32_t _flags_save_string = ndr->flags;
13255                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13256                         if (r->driver_name) {
13257                                 uint32_t _relative_save_offset;
13258                                 _relative_save_offset = ndr->offset;
13259                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13260                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13261                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13262                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13263                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13264                                 if (ndr->offset > ndr->relative_highest_offset) {
13265                                         ndr->relative_highest_offset = ndr->offset;
13266                                 }
13267                                 ndr->offset = _relative_save_offset;
13268                         }
13269                         ndr->flags = _flags_save_string;
13270                 }
13271                 {
13272                         uint32_t _flags_save_string = ndr->flags;
13273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13274                         if (r->inf_name) {
13275                                 uint32_t _relative_save_offset;
13276                                 _relative_save_offset = ndr->offset;
13277                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13278                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13279                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13280                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13281                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13282                                 if (ndr->offset > ndr->relative_highest_offset) {
13283                                         ndr->relative_highest_offset = ndr->offset;
13284                                 }
13285                                 ndr->offset = _relative_save_offset;
13286                         }
13287                         ndr->flags = _flags_save_string;
13288                 }
13289                 {
13290                         uint32_t _flags_save_string = ndr->flags;
13291                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13292                         if (r->install_source_root) {
13293                                 uint32_t _relative_save_offset;
13294                                 _relative_save_offset = ndr->offset;
13295                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13296                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13297                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13298                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13299                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13300                                 if (ndr->offset > ndr->relative_highest_offset) {
13301                                         ndr->relative_highest_offset = ndr->offset;
13302                                 }
13303                                 ndr->offset = _relative_save_offset;
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307         }
13308         return NDR_ERR_SUCCESS;
13309 }
13310
13311 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13312 {
13313         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13314         ndr->depth++;
13315         ndr_print_uint32(ndr, "size", r->size);
13316         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13317         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13318         ndr->depth++;
13319         if (r->driver_name) {
13320                 ndr_print_string(ndr, "driver_name", r->driver_name);
13321         }
13322         ndr->depth--;
13323         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13324         ndr->depth++;
13325         if (r->inf_name) {
13326                 ndr_print_string(ndr, "inf_name", r->inf_name);
13327         }
13328         ndr->depth--;
13329         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13330         ndr->depth++;
13331         if (r->install_source_root) {
13332                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13333         }
13334         ndr->depth--;
13335         ndr->depth--;
13336 }
13337
13338 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13339 {
13340         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13341 }
13342
13343 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13344 {
13345         if (ndr_flags & NDR_SCALARS) {
13346                 NDR_CHECK(ndr_push_align(ndr, 8));
13347                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13348                 {
13349                         uint32_t _flags_save_string = ndr->flags;
13350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13351                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13352                         ndr->flags = _flags_save_string;
13353                 }
13354                 {
13355                         uint32_t _flags_save_string = ndr->flags;
13356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13357                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13358                         ndr->flags = _flags_save_string;
13359                 }
13360                 {
13361                         uint32_t _flags_save_string = ndr->flags;
13362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13363                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13364                         ndr->flags = _flags_save_string;
13365                 }
13366                 {
13367                         uint32_t _flags_save_string = ndr->flags;
13368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13369                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13370                         ndr->flags = _flags_save_string;
13371                 }
13372                 {
13373                         uint32_t _flags_save_string = ndr->flags;
13374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13375                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13376                         ndr->flags = _flags_save_string;
13377                 }
13378                 {
13379                         uint32_t _flags_save_string = ndr->flags;
13380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13381                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13382                         ndr->flags = _flags_save_string;
13383                 }
13384                 {
13385                         uint32_t _flags_save_string_array = ndr->flags;
13386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13387                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13388                         ndr->flags = _flags_save_string_array;
13389                 }
13390                 {
13391                         uint32_t _flags_save_string = ndr->flags;
13392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13393                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13394                         ndr->flags = _flags_save_string;
13395                 }
13396                 {
13397                         uint32_t _flags_save_string = ndr->flags;
13398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13400                         ndr->flags = _flags_save_string;
13401                 }
13402                 {
13403                         uint32_t _flags_save_string_array = ndr->flags;
13404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13405                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13406                         ndr->flags = _flags_save_string_array;
13407                 }
13408                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13409                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13410                 {
13411                         uint32_t _flags_save_string = ndr->flags;
13412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13413                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13414                         ndr->flags = _flags_save_string;
13415                 }
13416                 {
13417                         uint32_t _flags_save_string = ndr->flags;
13418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13419                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13420                         ndr->flags = _flags_save_string;
13421                 }
13422                 {
13423                         uint32_t _flags_save_string = ndr->flags;
13424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13425                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13426                         ndr->flags = _flags_save_string;
13427                 }
13428                 {
13429                         uint32_t _flags_save_string = ndr->flags;
13430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13431                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13432                         ndr->flags = _flags_save_string;
13433                 }
13434                 {
13435                         uint32_t _flags_save_string = ndr->flags;
13436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13438                         ndr->flags = _flags_save_string;
13439                 }
13440                 {
13441                         uint32_t _flags_save_string = ndr->flags;
13442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13443                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13444                         ndr->flags = _flags_save_string;
13445                 }
13446                 {
13447                         uint32_t _flags_save_string_array = ndr->flags;
13448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13449                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13450                         ndr->flags = _flags_save_string_array;
13451                 }
13452                 {
13453                         uint32_t _flags_save_string = ndr->flags;
13454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13455                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13456                         ndr->flags = _flags_save_string;
13457                 }
13458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13459                 {
13460                         uint32_t _flags_save_string_array = ndr->flags;
13461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13462                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13463                         ndr->flags = _flags_save_string_array;
13464                 }
13465                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13466                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13467                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13468         }
13469         if (ndr_flags & NDR_BUFFERS) {
13470                 {
13471                         uint32_t _flags_save_string = ndr->flags;
13472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13473                         if (r->driver_name) {
13474                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13475                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13476                         }
13477                         ndr->flags = _flags_save_string;
13478                 }
13479                 {
13480                         uint32_t _flags_save_string = ndr->flags;
13481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13482                         if (r->architecture) {
13483                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
13484                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13485                         }
13486                         ndr->flags = _flags_save_string;
13487                 }
13488                 {
13489                         uint32_t _flags_save_string = ndr->flags;
13490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13491                         if (r->driver_path) {
13492                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
13493                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13494                         }
13495                         ndr->flags = _flags_save_string;
13496                 }
13497                 {
13498                         uint32_t _flags_save_string = ndr->flags;
13499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13500                         if (r->data_file) {
13501                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13502                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13503                         }
13504                         ndr->flags = _flags_save_string;
13505                 }
13506                 {
13507                         uint32_t _flags_save_string = ndr->flags;
13508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13509                         if (r->config_file) {
13510                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13511                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13512                         }
13513                         ndr->flags = _flags_save_string;
13514                 }
13515                 {
13516                         uint32_t _flags_save_string = ndr->flags;
13517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13518                         if (r->help_file) {
13519                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13520                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13521                         }
13522                         ndr->flags = _flags_save_string;
13523                 }
13524                 {
13525                         uint32_t _flags_save_string_array = ndr->flags;
13526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13527                         if (r->dependent_files) {
13528                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13529                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13530                         }
13531                         ndr->flags = _flags_save_string_array;
13532                 }
13533                 {
13534                         uint32_t _flags_save_string = ndr->flags;
13535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13536                         if (r->monitor_name) {
13537                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13538                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13539                         }
13540                         ndr->flags = _flags_save_string;
13541                 }
13542                 {
13543                         uint32_t _flags_save_string = ndr->flags;
13544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13545                         if (r->default_datatype) {
13546                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13547                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13548                         }
13549                         ndr->flags = _flags_save_string;
13550                 }
13551                 {
13552                         uint32_t _flags_save_string_array = ndr->flags;
13553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13554                         if (r->previous_names) {
13555                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13556                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13557                         }
13558                         ndr->flags = _flags_save_string_array;
13559                 }
13560                 {
13561                         uint32_t _flags_save_string = ndr->flags;
13562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13563                         if (r->manufacturer_name) {
13564                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13565                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13566                         }
13567                         ndr->flags = _flags_save_string;
13568                 }
13569                 {
13570                         uint32_t _flags_save_string = ndr->flags;
13571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13572                         if (r->manufacturer_url) {
13573                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13574                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13575                         }
13576                         ndr->flags = _flags_save_string;
13577                 }
13578                 {
13579                         uint32_t _flags_save_string = ndr->flags;
13580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13581                         if (r->hardware_id) {
13582                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13583                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13584                         }
13585                         ndr->flags = _flags_save_string;
13586                 }
13587                 {
13588                         uint32_t _flags_save_string = ndr->flags;
13589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13590                         if (r->provider) {
13591                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13592                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13593                         }
13594                         ndr->flags = _flags_save_string;
13595                 }
13596                 {
13597                         uint32_t _flags_save_string = ndr->flags;
13598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13599                         if (r->print_processor) {
13600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13602                         }
13603                         ndr->flags = _flags_save_string;
13604                 }
13605                 {
13606                         uint32_t _flags_save_string = ndr->flags;
13607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13608                         if (r->vendor_setup) {
13609                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13610                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13611                         }
13612                         ndr->flags = _flags_save_string;
13613                 }
13614                 {
13615                         uint32_t _flags_save_string_array = ndr->flags;
13616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13617                         if (r->color_profiles) {
13618                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13619                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13620                         }
13621                         ndr->flags = _flags_save_string_array;
13622                 }
13623                 {
13624                         uint32_t _flags_save_string = ndr->flags;
13625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13626                         if (r->inf_path) {
13627                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13628                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13629                         }
13630                         ndr->flags = _flags_save_string;
13631                 }
13632                 {
13633                         uint32_t _flags_save_string_array = ndr->flags;
13634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13635                         if (r->core_driver_dependencies) {
13636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13637                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13638                         }
13639                         ndr->flags = _flags_save_string_array;
13640                 }
13641         }
13642         return NDR_ERR_SUCCESS;
13643 }
13644
13645 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13646 {
13647         uint32_t _ptr_driver_name;
13648         TALLOC_CTX *_mem_save_driver_name_0;
13649         uint32_t _ptr_architecture;
13650         TALLOC_CTX *_mem_save_architecture_0;
13651         uint32_t _ptr_driver_path;
13652         TALLOC_CTX *_mem_save_driver_path_0;
13653         uint32_t _ptr_data_file;
13654         TALLOC_CTX *_mem_save_data_file_0;
13655         uint32_t _ptr_config_file;
13656         TALLOC_CTX *_mem_save_config_file_0;
13657         uint32_t _ptr_help_file;
13658         TALLOC_CTX *_mem_save_help_file_0;
13659         uint32_t _ptr_dependent_files;
13660         TALLOC_CTX *_mem_save_dependent_files_0;
13661         uint32_t _ptr_monitor_name;
13662         TALLOC_CTX *_mem_save_monitor_name_0;
13663         uint32_t _ptr_default_datatype;
13664         TALLOC_CTX *_mem_save_default_datatype_0;
13665         uint32_t _ptr_previous_names;
13666         TALLOC_CTX *_mem_save_previous_names_0;
13667         uint32_t _ptr_manufacturer_name;
13668         TALLOC_CTX *_mem_save_manufacturer_name_0;
13669         uint32_t _ptr_manufacturer_url;
13670         TALLOC_CTX *_mem_save_manufacturer_url_0;
13671         uint32_t _ptr_hardware_id;
13672         TALLOC_CTX *_mem_save_hardware_id_0;
13673         uint32_t _ptr_provider;
13674         TALLOC_CTX *_mem_save_provider_0;
13675         uint32_t _ptr_print_processor;
13676         TALLOC_CTX *_mem_save_print_processor_0;
13677         uint32_t _ptr_vendor_setup;
13678         TALLOC_CTX *_mem_save_vendor_setup_0;
13679         uint32_t _ptr_color_profiles;
13680         TALLOC_CTX *_mem_save_color_profiles_0;
13681         uint32_t _ptr_inf_path;
13682         TALLOC_CTX *_mem_save_inf_path_0;
13683         uint32_t _ptr_core_driver_dependencies;
13684         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13685         if (ndr_flags & NDR_SCALARS) {
13686                 NDR_CHECK(ndr_pull_align(ndr, 8));
13687                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13688                 {
13689                         uint32_t _flags_save_string = ndr->flags;
13690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13691                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13692                         if (_ptr_driver_name) {
13693                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13694                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13695                         } else {
13696                                 r->driver_name = NULL;
13697                         }
13698                         ndr->flags = _flags_save_string;
13699                 }
13700                 {
13701                         uint32_t _flags_save_string = ndr->flags;
13702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13704                         if (_ptr_architecture) {
13705                                 NDR_PULL_ALLOC(ndr, r->architecture);
13706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13707                         } else {
13708                                 r->architecture = NULL;
13709                         }
13710                         ndr->flags = _flags_save_string;
13711                 }
13712                 {
13713                         uint32_t _flags_save_string = ndr->flags;
13714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13716                         if (_ptr_driver_path) {
13717                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13719                         } else {
13720                                 r->driver_path = NULL;
13721                         }
13722                         ndr->flags = _flags_save_string;
13723                 }
13724                 {
13725                         uint32_t _flags_save_string = ndr->flags;
13726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13728                         if (_ptr_data_file) {
13729                                 NDR_PULL_ALLOC(ndr, r->data_file);
13730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13731                         } else {
13732                                 r->data_file = NULL;
13733                         }
13734                         ndr->flags = _flags_save_string;
13735                 }
13736                 {
13737                         uint32_t _flags_save_string = ndr->flags;
13738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13740                         if (_ptr_config_file) {
13741                                 NDR_PULL_ALLOC(ndr, r->config_file);
13742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13743                         } else {
13744                                 r->config_file = NULL;
13745                         }
13746                         ndr->flags = _flags_save_string;
13747                 }
13748                 {
13749                         uint32_t _flags_save_string = ndr->flags;
13750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13752                         if (_ptr_help_file) {
13753                                 NDR_PULL_ALLOC(ndr, r->help_file);
13754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13755                         } else {
13756                                 r->help_file = NULL;
13757                         }
13758                         ndr->flags = _flags_save_string;
13759                 }
13760                 {
13761                         uint32_t _flags_save_string_array = ndr->flags;
13762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13764                         if (_ptr_dependent_files) {
13765                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13767                         } else {
13768                                 r->dependent_files = NULL;
13769                         }
13770                         ndr->flags = _flags_save_string_array;
13771                 }
13772                 {
13773                         uint32_t _flags_save_string = ndr->flags;
13774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13776                         if (_ptr_monitor_name) {
13777                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13779                         } else {
13780                                 r->monitor_name = NULL;
13781                         }
13782                         ndr->flags = _flags_save_string;
13783                 }
13784                 {
13785                         uint32_t _flags_save_string = ndr->flags;
13786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13788                         if (_ptr_default_datatype) {
13789                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13791                         } else {
13792                                 r->default_datatype = NULL;
13793                         }
13794                         ndr->flags = _flags_save_string;
13795                 }
13796                 {
13797                         uint32_t _flags_save_string_array = ndr->flags;
13798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13800                         if (_ptr_previous_names) {
13801                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13803                         } else {
13804                                 r->previous_names = NULL;
13805                         }
13806                         ndr->flags = _flags_save_string_array;
13807                 }
13808                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13809                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13810                 {
13811                         uint32_t _flags_save_string = ndr->flags;
13812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13814                         if (_ptr_manufacturer_name) {
13815                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13817                         } else {
13818                                 r->manufacturer_name = NULL;
13819                         }
13820                         ndr->flags = _flags_save_string;
13821                 }
13822                 {
13823                         uint32_t _flags_save_string = ndr->flags;
13824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13825                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13826                         if (_ptr_manufacturer_url) {
13827                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13828                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13829                         } else {
13830                                 r->manufacturer_url = NULL;
13831                         }
13832                         ndr->flags = _flags_save_string;
13833                 }
13834                 {
13835                         uint32_t _flags_save_string = ndr->flags;
13836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13837                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13838                         if (_ptr_hardware_id) {
13839                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13840                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13841                         } else {
13842                                 r->hardware_id = NULL;
13843                         }
13844                         ndr->flags = _flags_save_string;
13845                 }
13846                 {
13847                         uint32_t _flags_save_string = ndr->flags;
13848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13849                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13850                         if (_ptr_provider) {
13851                                 NDR_PULL_ALLOC(ndr, r->provider);
13852                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13853                         } else {
13854                                 r->provider = NULL;
13855                         }
13856                         ndr->flags = _flags_save_string;
13857                 }
13858                 {
13859                         uint32_t _flags_save_string = ndr->flags;
13860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13862                         if (_ptr_print_processor) {
13863                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13865                         } else {
13866                                 r->print_processor = NULL;
13867                         }
13868                         ndr->flags = _flags_save_string;
13869                 }
13870                 {
13871                         uint32_t _flags_save_string = ndr->flags;
13872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13873                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13874                         if (_ptr_vendor_setup) {
13875                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13876                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13877                         } else {
13878                                 r->vendor_setup = NULL;
13879                         }
13880                         ndr->flags = _flags_save_string;
13881                 }
13882                 {
13883                         uint32_t _flags_save_string_array = ndr->flags;
13884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13885                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13886                         if (_ptr_color_profiles) {
13887                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13888                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13889                         } else {
13890                                 r->color_profiles = NULL;
13891                         }
13892                         ndr->flags = _flags_save_string_array;
13893                 }
13894                 {
13895                         uint32_t _flags_save_string = ndr->flags;
13896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13897                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13898                         if (_ptr_inf_path) {
13899                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13900                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13901                         } else {
13902                                 r->inf_path = NULL;
13903                         }
13904                         ndr->flags = _flags_save_string;
13905                 }
13906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13907                 {
13908                         uint32_t _flags_save_string_array = ndr->flags;
13909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13911                         if (_ptr_core_driver_dependencies) {
13912                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13914                         } else {
13915                                 r->core_driver_dependencies = NULL;
13916                         }
13917                         ndr->flags = _flags_save_string_array;
13918                 }
13919                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13920                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13921                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13922         }
13923         if (ndr_flags & NDR_BUFFERS) {
13924                 {
13925                         uint32_t _flags_save_string = ndr->flags;
13926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13927                         if (r->driver_name) {
13928                                 uint32_t _relative_save_offset;
13929                                 _relative_save_offset = ndr->offset;
13930                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13931                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13932                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13933                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13934                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13935                                 if (ndr->offset > ndr->relative_highest_offset) {
13936                                         ndr->relative_highest_offset = ndr->offset;
13937                                 }
13938                                 ndr->offset = _relative_save_offset;
13939                         }
13940                         ndr->flags = _flags_save_string;
13941                 }
13942                 {
13943                         uint32_t _flags_save_string = ndr->flags;
13944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13945                         if (r->architecture) {
13946                                 uint32_t _relative_save_offset;
13947                                 _relative_save_offset = ndr->offset;
13948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13949                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13950                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13953                                 if (ndr->offset > ndr->relative_highest_offset) {
13954                                         ndr->relative_highest_offset = ndr->offset;
13955                                 }
13956                                 ndr->offset = _relative_save_offset;
13957                         }
13958                         ndr->flags = _flags_save_string;
13959                 }
13960                 {
13961                         uint32_t _flags_save_string = ndr->flags;
13962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13963                         if (r->driver_path) {
13964                                 uint32_t _relative_save_offset;
13965                                 _relative_save_offset = ndr->offset;
13966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13967                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13968                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13971                                 if (ndr->offset > ndr->relative_highest_offset) {
13972                                         ndr->relative_highest_offset = ndr->offset;
13973                                 }
13974                                 ndr->offset = _relative_save_offset;
13975                         }
13976                         ndr->flags = _flags_save_string;
13977                 }
13978                 {
13979                         uint32_t _flags_save_string = ndr->flags;
13980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13981                         if (r->data_file) {
13982                                 uint32_t _relative_save_offset;
13983                                 _relative_save_offset = ndr->offset;
13984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13985                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13986                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13989                                 if (ndr->offset > ndr->relative_highest_offset) {
13990                                         ndr->relative_highest_offset = ndr->offset;
13991                                 }
13992                                 ndr->offset = _relative_save_offset;
13993                         }
13994                         ndr->flags = _flags_save_string;
13995                 }
13996                 {
13997                         uint32_t _flags_save_string = ndr->flags;
13998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13999                         if (r->config_file) {
14000                                 uint32_t _relative_save_offset;
14001                                 _relative_save_offset = ndr->offset;
14002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14003                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14004                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14007                                 if (ndr->offset > ndr->relative_highest_offset) {
14008                                         ndr->relative_highest_offset = ndr->offset;
14009                                 }
14010                                 ndr->offset = _relative_save_offset;
14011                         }
14012                         ndr->flags = _flags_save_string;
14013                 }
14014                 {
14015                         uint32_t _flags_save_string = ndr->flags;
14016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14017                         if (r->help_file) {
14018                                 uint32_t _relative_save_offset;
14019                                 _relative_save_offset = ndr->offset;
14020                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14021                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14022                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14023                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14024                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14025                                 if (ndr->offset > ndr->relative_highest_offset) {
14026                                         ndr->relative_highest_offset = ndr->offset;
14027                                 }
14028                                 ndr->offset = _relative_save_offset;
14029                         }
14030                         ndr->flags = _flags_save_string;
14031                 }
14032                 {
14033                         uint32_t _flags_save_string_array = ndr->flags;
14034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14035                         if (r->dependent_files) {
14036                                 uint32_t _relative_save_offset;
14037                                 _relative_save_offset = ndr->offset;
14038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14039                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14040                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14041                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14043                                 if (ndr->offset > ndr->relative_highest_offset) {
14044                                         ndr->relative_highest_offset = ndr->offset;
14045                                 }
14046                                 ndr->offset = _relative_save_offset;
14047                         }
14048                         ndr->flags = _flags_save_string_array;
14049                 }
14050                 {
14051                         uint32_t _flags_save_string = ndr->flags;
14052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14053                         if (r->monitor_name) {
14054                                 uint32_t _relative_save_offset;
14055                                 _relative_save_offset = ndr->offset;
14056                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14057                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14058                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14059                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14060                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14061                                 if (ndr->offset > ndr->relative_highest_offset) {
14062                                         ndr->relative_highest_offset = ndr->offset;
14063                                 }
14064                                 ndr->offset = _relative_save_offset;
14065                         }
14066                         ndr->flags = _flags_save_string;
14067                 }
14068                 {
14069                         uint32_t _flags_save_string = ndr->flags;
14070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14071                         if (r->default_datatype) {
14072                                 uint32_t _relative_save_offset;
14073                                 _relative_save_offset = ndr->offset;
14074                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14075                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14076                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14077                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14078                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14079                                 if (ndr->offset > ndr->relative_highest_offset) {
14080                                         ndr->relative_highest_offset = ndr->offset;
14081                                 }
14082                                 ndr->offset = _relative_save_offset;
14083                         }
14084                         ndr->flags = _flags_save_string;
14085                 }
14086                 {
14087                         uint32_t _flags_save_string_array = ndr->flags;
14088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14089                         if (r->previous_names) {
14090                                 uint32_t _relative_save_offset;
14091                                 _relative_save_offset = ndr->offset;
14092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14093                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14094                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14095                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14097                                 if (ndr->offset > ndr->relative_highest_offset) {
14098                                         ndr->relative_highest_offset = ndr->offset;
14099                                 }
14100                                 ndr->offset = _relative_save_offset;
14101                         }
14102                         ndr->flags = _flags_save_string_array;
14103                 }
14104                 {
14105                         uint32_t _flags_save_string = ndr->flags;
14106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14107                         if (r->manufacturer_name) {
14108                                 uint32_t _relative_save_offset;
14109                                 _relative_save_offset = ndr->offset;
14110                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14111                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14112                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14113                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14114                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14115                                 if (ndr->offset > ndr->relative_highest_offset) {
14116                                         ndr->relative_highest_offset = ndr->offset;
14117                                 }
14118                                 ndr->offset = _relative_save_offset;
14119                         }
14120                         ndr->flags = _flags_save_string;
14121                 }
14122                 {
14123                         uint32_t _flags_save_string = ndr->flags;
14124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14125                         if (r->manufacturer_url) {
14126                                 uint32_t _relative_save_offset;
14127                                 _relative_save_offset = ndr->offset;
14128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14129                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14130                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14133                                 if (ndr->offset > ndr->relative_highest_offset) {
14134                                         ndr->relative_highest_offset = ndr->offset;
14135                                 }
14136                                 ndr->offset = _relative_save_offset;
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                         if (r->hardware_id) {
14144                                 uint32_t _relative_save_offset;
14145                                 _relative_save_offset = ndr->offset;
14146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14147                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14148                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14151                                 if (ndr->offset > ndr->relative_highest_offset) {
14152                                         ndr->relative_highest_offset = ndr->offset;
14153                                 }
14154                                 ndr->offset = _relative_save_offset;
14155                         }
14156                         ndr->flags = _flags_save_string;
14157                 }
14158                 {
14159                         uint32_t _flags_save_string = ndr->flags;
14160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14161                         if (r->provider) {
14162                                 uint32_t _relative_save_offset;
14163                                 _relative_save_offset = ndr->offset;
14164                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14165                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14166                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14167                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14168                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14169                                 if (ndr->offset > ndr->relative_highest_offset) {
14170                                         ndr->relative_highest_offset = ndr->offset;
14171                                 }
14172                                 ndr->offset = _relative_save_offset;
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                         if (r->print_processor) {
14180                                 uint32_t _relative_save_offset;
14181                                 _relative_save_offset = ndr->offset;
14182                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14183                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14184                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14185                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14186                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14187                                 if (ndr->offset > ndr->relative_highest_offset) {
14188                                         ndr->relative_highest_offset = ndr->offset;
14189                                 }
14190                                 ndr->offset = _relative_save_offset;
14191                         }
14192                         ndr->flags = _flags_save_string;
14193                 }
14194                 {
14195                         uint32_t _flags_save_string = ndr->flags;
14196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14197                         if (r->vendor_setup) {
14198                                 uint32_t _relative_save_offset;
14199                                 _relative_save_offset = ndr->offset;
14200                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14201                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14202                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14203                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14204                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14205                                 if (ndr->offset > ndr->relative_highest_offset) {
14206                                         ndr->relative_highest_offset = ndr->offset;
14207                                 }
14208                                 ndr->offset = _relative_save_offset;
14209                         }
14210                         ndr->flags = _flags_save_string;
14211                 }
14212                 {
14213                         uint32_t _flags_save_string_array = ndr->flags;
14214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14215                         if (r->color_profiles) {
14216                                 uint32_t _relative_save_offset;
14217                                 _relative_save_offset = ndr->offset;
14218                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14219                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14220                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14221                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14222                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14223                                 if (ndr->offset > ndr->relative_highest_offset) {
14224                                         ndr->relative_highest_offset = ndr->offset;
14225                                 }
14226                                 ndr->offset = _relative_save_offset;
14227                         }
14228                         ndr->flags = _flags_save_string_array;
14229                 }
14230                 {
14231                         uint32_t _flags_save_string = ndr->flags;
14232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14233                         if (r->inf_path) {
14234                                 uint32_t _relative_save_offset;
14235                                 _relative_save_offset = ndr->offset;
14236                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14237                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14238                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14239                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14240                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14241                                 if (ndr->offset > ndr->relative_highest_offset) {
14242                                         ndr->relative_highest_offset = ndr->offset;
14243                                 }
14244                                 ndr->offset = _relative_save_offset;
14245                         }
14246                         ndr->flags = _flags_save_string;
14247                 }
14248                 {
14249                         uint32_t _flags_save_string_array = ndr->flags;
14250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14251                         if (r->core_driver_dependencies) {
14252                                 uint32_t _relative_save_offset;
14253                                 _relative_save_offset = ndr->offset;
14254                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14255                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14256                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14257                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14258                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14259                                 if (ndr->offset > ndr->relative_highest_offset) {
14260                                         ndr->relative_highest_offset = ndr->offset;
14261                                 }
14262                                 ndr->offset = _relative_save_offset;
14263                         }
14264                         ndr->flags = _flags_save_string_array;
14265                 }
14266         }
14267         return NDR_ERR_SUCCESS;
14268 }
14269
14270 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14271 {
14272         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14273         ndr->depth++;
14274         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14275         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14276         ndr->depth++;
14277         if (r->driver_name) {
14278                 ndr_print_string(ndr, "driver_name", r->driver_name);
14279         }
14280         ndr->depth--;
14281         ndr_print_ptr(ndr, "architecture", r->architecture);
14282         ndr->depth++;
14283         if (r->architecture) {
14284                 ndr_print_string(ndr, "architecture", r->architecture);
14285         }
14286         ndr->depth--;
14287         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14288         ndr->depth++;
14289         if (r->driver_path) {
14290                 ndr_print_string(ndr, "driver_path", r->driver_path);
14291         }
14292         ndr->depth--;
14293         ndr_print_ptr(ndr, "data_file", r->data_file);
14294         ndr->depth++;
14295         if (r->data_file) {
14296                 ndr_print_string(ndr, "data_file", r->data_file);
14297         }
14298         ndr->depth--;
14299         ndr_print_ptr(ndr, "config_file", r->config_file);
14300         ndr->depth++;
14301         if (r->config_file) {
14302                 ndr_print_string(ndr, "config_file", r->config_file);
14303         }
14304         ndr->depth--;
14305         ndr_print_ptr(ndr, "help_file", r->help_file);
14306         ndr->depth++;
14307         if (r->help_file) {
14308                 ndr_print_string(ndr, "help_file", r->help_file);
14309         }
14310         ndr->depth--;
14311         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14312         ndr->depth++;
14313         if (r->dependent_files) {
14314                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14315         }
14316         ndr->depth--;
14317         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14318         ndr->depth++;
14319         if (r->monitor_name) {
14320                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14321         }
14322         ndr->depth--;
14323         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14324         ndr->depth++;
14325         if (r->default_datatype) {
14326                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14327         }
14328         ndr->depth--;
14329         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14330         ndr->depth++;
14331         if (r->previous_names) {
14332                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14333         }
14334         ndr->depth--;
14335         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14336         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14337         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14338         ndr->depth++;
14339         if (r->manufacturer_name) {
14340                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14341         }
14342         ndr->depth--;
14343         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14344         ndr->depth++;
14345         if (r->manufacturer_url) {
14346                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14347         }
14348         ndr->depth--;
14349         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14350         ndr->depth++;
14351         if (r->hardware_id) {
14352                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14353         }
14354         ndr->depth--;
14355         ndr_print_ptr(ndr, "provider", r->provider);
14356         ndr->depth++;
14357         if (r->provider) {
14358                 ndr_print_string(ndr, "provider", r->provider);
14359         }
14360         ndr->depth--;
14361         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14362         ndr->depth++;
14363         if (r->print_processor) {
14364                 ndr_print_string(ndr, "print_processor", r->print_processor);
14365         }
14366         ndr->depth--;
14367         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14368         ndr->depth++;
14369         if (r->vendor_setup) {
14370                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14371         }
14372         ndr->depth--;
14373         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14374         ndr->depth++;
14375         if (r->color_profiles) {
14376                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14377         }
14378         ndr->depth--;
14379         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14380         ndr->depth++;
14381         if (r->inf_path) {
14382                 ndr_print_string(ndr, "inf_path", r->inf_path);
14383         }
14384         ndr->depth--;
14385         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14386         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14387         ndr->depth++;
14388         if (r->core_driver_dependencies) {
14389                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14390         }
14391         ndr->depth--;
14392         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14393         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14394         ndr->depth--;
14395 }
14396
14397 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14398 {
14399         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14400 }
14401
14402 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14403 {
14404         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14405         return NDR_ERR_SUCCESS;
14406 }
14407
14408 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14409 {
14410         uint32_t v;
14411         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14412         *r = v;
14413         return NDR_ERR_SUCCESS;
14414 }
14415
14416 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14417 {
14418         const char *val = NULL;
14419
14420         switch (r) {
14421                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14422                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14423                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14424                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14425                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14426         }
14427         ndr_print_enum(ndr, name, "ENUM", val, r);
14428 }
14429
14430 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14431 {
14432         if (ndr_flags & NDR_SCALARS) {
14433                 NDR_CHECK(ndr_push_align(ndr, 5));
14434                 {
14435                         uint32_t _flags_save_string = ndr->flags;
14436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14438                         ndr->flags = _flags_save_string;
14439                 }
14440                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14442                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14443         }
14444         if (ndr_flags & NDR_BUFFERS) {
14445                 {
14446                         uint32_t _flags_save_string = ndr->flags;
14447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14448                         if (r->file_name) {
14449                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
14450                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14451                         }
14452                         ndr->flags = _flags_save_string;
14453                 }
14454         }
14455         return NDR_ERR_SUCCESS;
14456 }
14457
14458 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14459 {
14460         uint32_t _ptr_file_name;
14461         TALLOC_CTX *_mem_save_file_name_0;
14462         if (ndr_flags & NDR_SCALARS) {
14463                 NDR_CHECK(ndr_pull_align(ndr, 5));
14464                 {
14465                         uint32_t _flags_save_string = ndr->flags;
14466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14467                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14468                         if (_ptr_file_name) {
14469                                 NDR_PULL_ALLOC(ndr, r->file_name);
14470                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14471                         } else {
14472                                 r->file_name = NULL;
14473                         }
14474                         ndr->flags = _flags_save_string;
14475                 }
14476                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14478                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14479         }
14480         if (ndr_flags & NDR_BUFFERS) {
14481                 {
14482                         uint32_t _flags_save_string = ndr->flags;
14483                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14484                         if (r->file_name) {
14485                                 uint32_t _relative_save_offset;
14486                                 _relative_save_offset = ndr->offset;
14487                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14488                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14489                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14490                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14491                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14492                                 if (ndr->offset > ndr->relative_highest_offset) {
14493                                         ndr->relative_highest_offset = ndr->offset;
14494                                 }
14495                                 ndr->offset = _relative_save_offset;
14496                         }
14497                         ndr->flags = _flags_save_string;
14498                 }
14499         }
14500         return NDR_ERR_SUCCESS;
14501 }
14502
14503 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14504 {
14505         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14506         ndr->depth++;
14507         ndr_print_ptr(ndr, "file_name", r->file_name);
14508         ndr->depth++;
14509         if (r->file_name) {
14510                 ndr_print_string(ndr, "file_name", r->file_name);
14511         }
14512         ndr->depth--;
14513         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14514         ndr_print_uint32(ndr, "file_version", r->file_version);
14515         ndr->depth--;
14516 }
14517
14518 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14519 {
14520         uint32_t cntr_file_info_1;
14521         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14522         ndr->depth++;
14523         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14524         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14525         ndr->depth++;
14526         if (r->driver_name) {
14527                 ndr_print_string(ndr, "driver_name", r->driver_name);
14528         }
14529         ndr->depth--;
14530         ndr_print_ptr(ndr, "architecture", r->architecture);
14531         ndr->depth++;
14532         if (r->architecture) {
14533                 ndr_print_string(ndr, "architecture", r->architecture);
14534         }
14535         ndr->depth--;
14536         ndr_print_ptr(ndr, "file_info", r->file_info);
14537         ndr->depth++;
14538         if (r->file_info) {
14539                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14540                 ndr->depth++;
14541                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14542                         char *idx_1=NULL;
14543                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14544                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14545                                 free(idx_1);
14546                         }
14547                 }
14548                 ndr->depth--;
14549         }
14550         ndr->depth--;
14551         ndr_print_uint32(ndr, "file_count", r->file_count);
14552         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14553         ndr->depth++;
14554         if (r->monitor_name) {
14555                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14556         }
14557         ndr->depth--;
14558         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14559         ndr->depth++;
14560         if (r->default_datatype) {
14561                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14562         }
14563         ndr->depth--;
14564         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14565         ndr->depth++;
14566         if (r->previous_names) {
14567                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14568         }
14569         ndr->depth--;
14570         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14571         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14572         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14573         ndr->depth++;
14574         if (r->manufacturer_name) {
14575                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14576         }
14577         ndr->depth--;
14578         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14579         ndr->depth++;
14580         if (r->manufacturer_url) {
14581                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14582         }
14583         ndr->depth--;
14584         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14585         ndr->depth++;
14586         if (r->hardware_id) {
14587                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14588         }
14589         ndr->depth--;
14590         ndr_print_ptr(ndr, "provider", r->provider);
14591         ndr->depth++;
14592         if (r->provider) {
14593                 ndr_print_string(ndr, "provider", r->provider);
14594         }
14595         ndr->depth--;
14596         ndr->depth--;
14597 }
14598
14599 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14600 {
14601         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14602 }
14603
14604 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14605 {
14606         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14607         if (ndr_flags & NDR_SCALARS) {
14608                 int level = ndr_push_get_switch_value(ndr, r);
14609                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14610                 switch (level) {
14611                         case 1: {
14612                                 NDR_CHECK(ndr_push_align(ndr, 5));
14613                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14614                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14615                         break; }
14616
14617                         case 2: {
14618                                 NDR_CHECK(ndr_push_align(ndr, 5));
14619                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14620                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14621                         break; }
14622
14623                         case 3: {
14624                                 NDR_CHECK(ndr_push_align(ndr, 5));
14625                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14626                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14627                         break; }
14628
14629                         case 4: {
14630                                 NDR_CHECK(ndr_push_align(ndr, 5));
14631                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14632                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14633                         break; }
14634
14635                         case 5: {
14636                                 NDR_CHECK(ndr_push_align(ndr, 5));
14637                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14638                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14639                         break; }
14640
14641                         case 6: {
14642                                 NDR_CHECK(ndr_push_align(ndr, 8));
14643                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14644                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14645                         break; }
14646
14647                         case 7: {
14648                                 NDR_CHECK(ndr_push_align(ndr, 5));
14649                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14650                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14651                         break; }
14652
14653                         case 8: {
14654                                 NDR_CHECK(ndr_push_align(ndr, 8));
14655                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14656                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14657                         break; }
14658
14659                         case 101: {
14660                                 NDR_CHECK(ndr_push_align(ndr, 8));
14661                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14662                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14663                         break; }
14664
14665                         default: {
14666                         break; }
14667
14668                 }
14669         }
14670         if (ndr_flags & NDR_BUFFERS) {
14671                 int level = ndr_push_get_switch_value(ndr, r);
14672                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14673                 switch (level) {
14674                         case 1:
14675                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14676                         break;
14677
14678                         case 2:
14679                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14680                         break;
14681
14682                         case 3:
14683                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14684                         break;
14685
14686                         case 4:
14687                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14688                         break;
14689
14690                         case 5:
14691                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14692                         break;
14693
14694                         case 6:
14695                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14696                         break;
14697
14698                         case 7:
14699                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14700                         break;
14701
14702                         case 8:
14703                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14704                         break;
14705
14706                         case 101:
14707                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14708                         break;
14709
14710                         default:
14711                         break;
14712
14713                 }
14714         }
14715         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14716         return NDR_ERR_SUCCESS;
14717 }
14718
14719 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14720 {
14721         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14722         int level;
14723         level = ndr_pull_get_switch_value(ndr, r);
14724         if (ndr_flags & NDR_SCALARS) {
14725                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14726                 switch (level) {
14727                         case 1: {
14728                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14729                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14730                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14731                         break; }
14732
14733                         case 2: {
14734                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14735                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14736                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14737                         break; }
14738
14739                         case 3: {
14740                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14741                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14742                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14743                         break; }
14744
14745                         case 4: {
14746                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14747                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14748                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14749                         break; }
14750
14751                         case 5: {
14752                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14753                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14754                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14755                         break; }
14756
14757                         case 6: {
14758                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14759                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14760                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14761                         break; }
14762
14763                         case 7: {
14764                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14765                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14766                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14767                         break; }
14768
14769                         case 8: {
14770                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14771                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14772                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14773                         break; }
14774
14775                         case 101: {
14776                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14777                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14778                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14779                         break; }
14780
14781                         default: {
14782                         break; }
14783
14784                 }
14785         }
14786         if (ndr_flags & NDR_BUFFERS) {
14787                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14788                 switch (level) {
14789                         case 1:
14790                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14791                         break;
14792
14793                         case 2:
14794                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14795                         break;
14796
14797                         case 3:
14798                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14799                         break;
14800
14801                         case 4:
14802                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14803                         break;
14804
14805                         case 5:
14806                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14807                         break;
14808
14809                         case 6:
14810                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14811                         break;
14812
14813                         case 7:
14814                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14815                         break;
14816
14817                         case 8:
14818                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14819                         break;
14820
14821                         case 101:
14822                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14823                         break;
14824
14825                         default:
14826                         break;
14827
14828                 }
14829         }
14830         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14831         return NDR_ERR_SUCCESS;
14832 }
14833
14834 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14835 {
14836         int level;
14837         level = ndr_print_get_switch_value(ndr, r);
14838         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14839         switch (level) {
14840                 case 1:
14841                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14842                 break;
14843
14844                 case 2:
14845                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14846                 break;
14847
14848                 case 3:
14849                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14850                 break;
14851
14852                 case 4:
14853                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14854                 break;
14855
14856                 case 5:
14857                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14858                 break;
14859
14860                 case 6:
14861                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14862                 break;
14863
14864                 case 7:
14865                         ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
14866                 break;
14867
14868                 case 8:
14869                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14870                 break;
14871
14872                 case 101:
14873                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14874                 break;
14875
14876                 default:
14877                 break;
14878
14879         }
14880 }
14881
14882 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14883 {
14884         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14885 }
14886
14887 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14888 {
14889         if (ndr_flags & NDR_SCALARS) {
14890                 NDR_CHECK(ndr_push_align(ndr, 4));
14891                 {
14892                         uint32_t _flags_save_string = ndr->flags;
14893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14894                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14895                         ndr->flags = _flags_save_string;
14896                 }
14897                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14898         }
14899         if (ndr_flags & NDR_BUFFERS) {
14900         }
14901         return NDR_ERR_SUCCESS;
14902 }
14903
14904 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14905 {
14906         if (ndr_flags & NDR_SCALARS) {
14907                 NDR_CHECK(ndr_pull_align(ndr, 4));
14908                 {
14909                         uint32_t _flags_save_string = ndr->flags;
14910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14911                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14912                         ndr->flags = _flags_save_string;
14913                 }
14914                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14915         }
14916         if (ndr_flags & NDR_BUFFERS) {
14917         }
14918         return NDR_ERR_SUCCESS;
14919 }
14920
14921 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14922 {
14923         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14924         ndr->depth++;
14925         ndr_print_string(ndr, "directory_name", r->directory_name);
14926         ndr->depth--;
14927 }
14928
14929 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14930 {
14931         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14932 }
14933
14934 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14935 {
14936         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14937         if (ndr_flags & NDR_SCALARS) {
14938                 int level = ndr_push_get_switch_value(ndr, r);
14939                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14940                 switch (level) {
14941                         case 1: {
14942                                 NDR_CHECK(ndr_push_align(ndr, 4));
14943                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14944                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14945                         break; }
14946
14947                         default: {
14948                                 NDR_CHECK(ndr_push_align(ndr, 4));
14949                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14950                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14951                         break; }
14952
14953                 }
14954         }
14955         if (ndr_flags & NDR_BUFFERS) {
14956                 int level = ndr_push_get_switch_value(ndr, r);
14957                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14958                 switch (level) {
14959                         case 1:
14960                         break;
14961
14962                         default:
14963                         break;
14964
14965                 }
14966         }
14967         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14968         return NDR_ERR_SUCCESS;
14969 }
14970
14971 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14972 {
14973         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14974         int level;
14975         level = ndr_pull_get_switch_value(ndr, r);
14976         if (ndr_flags & NDR_SCALARS) {
14977                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14978                 switch (level) {
14979                         case 1: {
14980                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14981                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14982                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14983                         break; }
14984
14985                         default: {
14986                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14987                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14988                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14989                         break; }
14990
14991                 }
14992         }
14993         if (ndr_flags & NDR_BUFFERS) {
14994                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14995                 switch (level) {
14996                         case 1:
14997                         break;
14998
14999                         default:
15000                         break;
15001
15002                 }
15003         }
15004         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15005         return NDR_ERR_SUCCESS;
15006 }
15007
15008 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15009 {
15010         int level;
15011         level = ndr_print_get_switch_value(ndr, r);
15012         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15013         switch (level) {
15014                 case 1:
15015                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15016                 break;
15017
15018                 default:
15019                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15020                 break;
15021
15022         }
15023 }
15024
15025 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15026 {
15027         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15028 }
15029
15030 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15031 {
15032         if (ndr_flags & NDR_SCALARS) {
15033                 NDR_CHECK(ndr_push_align(ndr, 5));
15034                 {
15035                         uint32_t _flags_save_string = ndr->flags;
15036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15037                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15038                         ndr->flags = _flags_save_string;
15039                 }
15040                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15041         }
15042         if (ndr_flags & NDR_BUFFERS) {
15043                 {
15044                         uint32_t _flags_save_string = ndr->flags;
15045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15046                         if (r->print_processor_name) {
15047                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
15048                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15049                         }
15050                         ndr->flags = _flags_save_string;
15051                 }
15052         }
15053         return NDR_ERR_SUCCESS;
15054 }
15055
15056 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15057 {
15058         uint32_t _ptr_print_processor_name;
15059         TALLOC_CTX *_mem_save_print_processor_name_0;
15060         if (ndr_flags & NDR_SCALARS) {
15061                 NDR_CHECK(ndr_pull_align(ndr, 5));
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15066                         if (_ptr_print_processor_name) {
15067                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15069                         } else {
15070                                 r->print_processor_name = NULL;
15071                         }
15072                         ndr->flags = _flags_save_string;
15073                 }
15074                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15075         }
15076         if (ndr_flags & NDR_BUFFERS) {
15077                 {
15078                         uint32_t _flags_save_string = ndr->flags;
15079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15080                         if (r->print_processor_name) {
15081                                 uint32_t _relative_save_offset;
15082                                 _relative_save_offset = ndr->offset;
15083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15084                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15088                                 if (ndr->offset > ndr->relative_highest_offset) {
15089                                         ndr->relative_highest_offset = ndr->offset;
15090                                 }
15091                                 ndr->offset = _relative_save_offset;
15092                         }
15093                         ndr->flags = _flags_save_string;
15094                 }
15095         }
15096         return NDR_ERR_SUCCESS;
15097 }
15098
15099 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15100 {
15101         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15102         ndr->depth++;
15103         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15104         ndr->depth++;
15105         if (r->print_processor_name) {
15106                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15107         }
15108         ndr->depth--;
15109         ndr->depth--;
15110 }
15111
15112 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15113 {
15114         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15115 }
15116
15117 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15118 {
15119         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15120         if (ndr_flags & NDR_SCALARS) {
15121                 int level = ndr_push_get_switch_value(ndr, r);
15122                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15123                 switch (level) {
15124                         case 1: {
15125                                 NDR_CHECK(ndr_push_align(ndr, 5));
15126                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15127                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15128                         break; }
15129
15130                         default: {
15131                         break; }
15132
15133                 }
15134         }
15135         if (ndr_flags & NDR_BUFFERS) {
15136                 int level = ndr_push_get_switch_value(ndr, r);
15137                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15138                 switch (level) {
15139                         case 1:
15140                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15141                         break;
15142
15143                         default:
15144                         break;
15145
15146                 }
15147         }
15148         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15149         return NDR_ERR_SUCCESS;
15150 }
15151
15152 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15153 {
15154         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15155         int level;
15156         level = ndr_pull_get_switch_value(ndr, r);
15157         if (ndr_flags & NDR_SCALARS) {
15158                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15159                 switch (level) {
15160                         case 1: {
15161                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15162                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15163                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15164                         break; }
15165
15166                         default: {
15167                         break; }
15168
15169                 }
15170         }
15171         if (ndr_flags & NDR_BUFFERS) {
15172                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15173                 switch (level) {
15174                         case 1:
15175                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15176                         break;
15177
15178                         default:
15179                         break;
15180
15181                 }
15182         }
15183         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15184         return NDR_ERR_SUCCESS;
15185 }
15186
15187 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15188 {
15189         int level;
15190         level = ndr_print_get_switch_value(ndr, r);
15191         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15192         switch (level) {
15193                 case 1:
15194                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15195                 break;
15196
15197                 default:
15198                 break;
15199
15200         }
15201 }
15202
15203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15204 {
15205         if (ndr_flags & NDR_SCALARS) {
15206                 NDR_CHECK(ndr_push_align(ndr, 4));
15207                 {
15208                         uint32_t _flags_save_string = ndr->flags;
15209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15210                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15211                         ndr->flags = _flags_save_string;
15212                 }
15213                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15214         }
15215         if (ndr_flags & NDR_BUFFERS) {
15216         }
15217         return NDR_ERR_SUCCESS;
15218 }
15219
15220 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15221 {
15222         if (ndr_flags & NDR_SCALARS) {
15223                 NDR_CHECK(ndr_pull_align(ndr, 4));
15224                 {
15225                         uint32_t _flags_save_string = ndr->flags;
15226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15227                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15228                         ndr->flags = _flags_save_string;
15229                 }
15230                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15231         }
15232         if (ndr_flags & NDR_BUFFERS) {
15233         }
15234         return NDR_ERR_SUCCESS;
15235 }
15236
15237 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15238 {
15239         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15240         ndr->depth++;
15241         ndr_print_string(ndr, "directory_name", r->directory_name);
15242         ndr->depth--;
15243 }
15244
15245 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15246 {
15247         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15248 }
15249
15250 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15251 {
15252         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15253         if (ndr_flags & NDR_SCALARS) {
15254                 int level = ndr_push_get_switch_value(ndr, r);
15255                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15256                 switch (level) {
15257                         case 1: {
15258                                 NDR_CHECK(ndr_push_align(ndr, 4));
15259                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15260                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15261                         break; }
15262
15263                         default: {
15264                                 NDR_CHECK(ndr_push_align(ndr, 4));
15265                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15266                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15267                         break; }
15268
15269                 }
15270         }
15271         if (ndr_flags & NDR_BUFFERS) {
15272                 int level = ndr_push_get_switch_value(ndr, r);
15273                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15274                 switch (level) {
15275                         case 1:
15276                         break;
15277
15278                         default:
15279                         break;
15280
15281                 }
15282         }
15283         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15284         return NDR_ERR_SUCCESS;
15285 }
15286
15287 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15288 {
15289         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15290         int level;
15291         level = ndr_pull_get_switch_value(ndr, r);
15292         if (ndr_flags & NDR_SCALARS) {
15293                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15294                 switch (level) {
15295                         case 1: {
15296                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15297                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15298                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15299                         break; }
15300
15301                         default: {
15302                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15303                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15304                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15305                         break; }
15306
15307                 }
15308         }
15309         if (ndr_flags & NDR_BUFFERS) {
15310                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15311                 switch (level) {
15312                         case 1:
15313                         break;
15314
15315                         default:
15316                         break;
15317
15318                 }
15319         }
15320         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15321         return NDR_ERR_SUCCESS;
15322 }
15323
15324 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15325 {
15326         int level;
15327         level = ndr_print_get_switch_value(ndr, r);
15328         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15329         switch (level) {
15330                 case 1:
15331                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15332                 break;
15333
15334                 default:
15335                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15336                 break;
15337
15338         }
15339 }
15340
15341 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15342 {
15343         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15344 }
15345
15346 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15347 {
15348         if (ndr_flags & NDR_SCALARS) {
15349                 NDR_CHECK(ndr_push_align(ndr, 5));
15350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15353                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15354         }
15355         if (ndr_flags & NDR_BUFFERS) {
15356                 if (r->document_name) {
15357                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15358                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15360                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15361                 }
15362                 if (r->output_file) {
15363                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15364                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15367                 }
15368                 if (r->datatype) {
15369                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15372                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15373                 }
15374         }
15375         return NDR_ERR_SUCCESS;
15376 }
15377
15378 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15379 {
15380         uint32_t _ptr_document_name;
15381         TALLOC_CTX *_mem_save_document_name_0;
15382         uint32_t _ptr_output_file;
15383         TALLOC_CTX *_mem_save_output_file_0;
15384         uint32_t _ptr_datatype;
15385         TALLOC_CTX *_mem_save_datatype_0;
15386         if (ndr_flags & NDR_SCALARS) {
15387                 NDR_CHECK(ndr_pull_align(ndr, 5));
15388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15389                 if (_ptr_document_name) {
15390                         NDR_PULL_ALLOC(ndr, r->document_name);
15391                 } else {
15392                         r->document_name = NULL;
15393                 }
15394                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15395                 if (_ptr_output_file) {
15396                         NDR_PULL_ALLOC(ndr, r->output_file);
15397                 } else {
15398                         r->output_file = NULL;
15399                 }
15400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15401                 if (_ptr_datatype) {
15402                         NDR_PULL_ALLOC(ndr, r->datatype);
15403                 } else {
15404                         r->datatype = NULL;
15405                 }
15406                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15407         }
15408         if (ndr_flags & NDR_BUFFERS) {
15409                 if (r->document_name) {
15410                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15411                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15412                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15413                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15414                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15415                                 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));
15416                         }
15417                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15418                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15420                 }
15421                 if (r->output_file) {
15422                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15423                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15425                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15426                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15427                                 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));
15428                         }
15429                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15430                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15432                 }
15433                 if (r->datatype) {
15434                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15435                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15438                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15439                                 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));
15440                         }
15441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15442                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15444                 }
15445         }
15446         return NDR_ERR_SUCCESS;
15447 }
15448
15449 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15450 {
15451         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15452         ndr->depth++;
15453         ndr_print_ptr(ndr, "document_name", r->document_name);
15454         ndr->depth++;
15455         if (r->document_name) {
15456                 ndr_print_string(ndr, "document_name", r->document_name);
15457         }
15458         ndr->depth--;
15459         ndr_print_ptr(ndr, "output_file", r->output_file);
15460         ndr->depth++;
15461         if (r->output_file) {
15462                 ndr_print_string(ndr, "output_file", r->output_file);
15463         }
15464         ndr->depth--;
15465         ndr_print_ptr(ndr, "datatype", r->datatype);
15466         ndr->depth++;
15467         if (r->datatype) {
15468                 ndr_print_string(ndr, "datatype", r->datatype);
15469         }
15470         ndr->depth--;
15471         ndr->depth--;
15472 }
15473
15474 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15475 {
15476         if (ndr_flags & NDR_SCALARS) {
15477                 int level = ndr_push_get_switch_value(ndr, r);
15478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15479                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15480                 switch (level) {
15481                         case 1: {
15482                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15483                         break; }
15484
15485                         case 2: {
15486                         break; }
15487
15488                         case 3: {
15489                         break; }
15490
15491                         default: {
15492                         break; }
15493
15494                 }
15495         }
15496         if (ndr_flags & NDR_BUFFERS) {
15497                 int level = ndr_push_get_switch_value(ndr, r);
15498                 switch (level) {
15499                         case 1:
15500                                 if (r->info1) {
15501                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15502                                 }
15503                         break;
15504
15505                         case 2:
15506                         break;
15507
15508                         case 3:
15509                         break;
15510
15511                         default:
15512                         break;
15513
15514                 }
15515         }
15516         return NDR_ERR_SUCCESS;
15517 }
15518
15519 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15520 {
15521         int level;
15522         uint32_t _level;
15523         TALLOC_CTX *_mem_save_info1_0;
15524         level = ndr_pull_get_switch_value(ndr, r);
15525         if (ndr_flags & NDR_SCALARS) {
15526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15527                 if (_level != level) {
15528                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15529                 }
15530                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15531                 switch (level) {
15532                         case 1: {
15533                                 uint32_t _ptr_info1;
15534                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15535                                 if (_ptr_info1) {
15536                                         NDR_PULL_ALLOC(ndr, r->info1);
15537                                 } else {
15538                                         r->info1 = NULL;
15539                                 }
15540                         break; }
15541
15542                         case 2: {
15543                         break; }
15544
15545                         case 3: {
15546                         break; }
15547
15548                         default: {
15549                         break; }
15550
15551                 }
15552         }
15553         if (ndr_flags & NDR_BUFFERS) {
15554                 switch (level) {
15555                         case 1:
15556                                 if (r->info1) {
15557                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15558                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15559                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15560                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15561                                 }
15562                         break;
15563
15564                         case 2:
15565                         break;
15566
15567                         case 3:
15568                         break;
15569
15570                         default:
15571                         break;
15572
15573                 }
15574         }
15575         return NDR_ERR_SUCCESS;
15576 }
15577
15578 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15579 {
15580         int level;
15581         level = ndr_print_get_switch_value(ndr, r);
15582         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15583         switch (level) {
15584                 case 1:
15585                         ndr_print_ptr(ndr, "info1", r->info1);
15586                         ndr->depth++;
15587                         if (r->info1) {
15588                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15589                         }
15590                         ndr->depth--;
15591                 break;
15592
15593                 case 2:
15594                 break;
15595
15596                 case 3:
15597                 break;
15598
15599                 default:
15600                 break;
15601
15602         }
15603 }
15604
15605 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15606 {
15607         if (ndr_flags & NDR_SCALARS) {
15608                 NDR_CHECK(ndr_push_align(ndr, 4));
15609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15614                 {
15615                         uint32_t _flags_save_string = ndr->flags;
15616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15617                         {
15618                                 struct ndr_push *_ndr_extra_string;
15619                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15620                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15621                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15622                         }
15623                         ndr->flags = _flags_save_string;
15624                 }
15625                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15626         }
15627         if (ndr_flags & NDR_BUFFERS) {
15628         }
15629         return NDR_ERR_SUCCESS;
15630 }
15631
15632 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15633 {
15634         if (ndr_flags & NDR_SCALARS) {
15635                 NDR_CHECK(ndr_pull_align(ndr, 4));
15636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15641                 {
15642                         uint32_t _flags_save_string = ndr->flags;
15643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15644                         {
15645                                 struct ndr_pull *_ndr_extra_string;
15646                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15647                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15648                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15649                         }
15650                         ndr->flags = _flags_save_string;
15651                 }
15652                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15653         }
15654         if (ndr_flags & NDR_BUFFERS) {
15655         }
15656         return NDR_ERR_SUCCESS;
15657 }
15658
15659 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15660 {
15661         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15662         ndr->depth++;
15663         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);
15664         ndr_print_uint32(ndr, "major", r->major);
15665         ndr_print_uint32(ndr, "minor", r->minor);
15666         ndr_print_uint32(ndr, "build", r->build);
15667         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15668         ndr_print_string(ndr, "extra_string", r->extra_string);
15669         ndr->depth--;
15670 }
15671
15672 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15673 {
15674         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15675 }
15676
15677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15678 {
15679         if (ndr_flags & NDR_SCALARS) {
15680                 NDR_CHECK(ndr_push_align(ndr, 4));
15681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15686                 {
15687                         uint32_t _flags_save_string = ndr->flags;
15688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15689                         {
15690                                 struct ndr_push *_ndr_extra_string;
15691                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15692                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15693                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15694                         }
15695                         ndr->flags = _flags_save_string;
15696                 }
15697                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15698                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15699                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15700                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15701                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
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_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15710 {
15711         if (ndr_flags & NDR_SCALARS) {
15712                 NDR_CHECK(ndr_pull_align(ndr, 4));
15713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15718                 {
15719                         uint32_t _flags_save_string = ndr->flags;
15720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15721                         {
15722                                 struct ndr_pull *_ndr_extra_string;
15723                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15724                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15725                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15726                         }
15727                         ndr->flags = _flags_save_string;
15728                 }
15729                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15730                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15731                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15732                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15733                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15734                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15735         }
15736         if (ndr_flags & NDR_BUFFERS) {
15737         }
15738         return NDR_ERR_SUCCESS;
15739 }
15740
15741 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15742 {
15743         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15744         ndr->depth++;
15745         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);
15746         ndr_print_uint32(ndr, "major", r->major);
15747         ndr_print_uint32(ndr, "minor", r->minor);
15748         ndr_print_uint32(ndr, "build", r->build);
15749         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15750         ndr_print_string(ndr, "extra_string", r->extra_string);
15751         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15752         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15753         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15754         ndr_print_uint8(ndr, "product_type", r->product_type);
15755         ndr_print_uint8(ndr, "reserved", r->reserved);
15756         ndr->depth--;
15757 }
15758
15759 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15760 {
15761         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15762 }
15763
15764 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15765 {
15766         if (ndr_flags & NDR_SCALARS) {
15767                 int level = ndr_push_get_switch_value(ndr, r);
15768                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15769                 switch (level) {
15770                         case REG_NONE: {
15771                         break; }
15772
15773                         case REG_SZ: {
15774                                 {
15775                                         uint32_t _flags_save_string = ndr->flags;
15776                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15777                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15778                                         ndr->flags = _flags_save_string;
15779                                 }
15780                         break; }
15781
15782                         case REG_BINARY: {
15783                                 {
15784                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15785                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15786                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15787                                         ndr->flags = _flags_save_DATA_BLOB;
15788                                 }
15789                         break; }
15790
15791                         case REG_DWORD: {
15792                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15793                         break; }
15794
15795                         case REG_MULTI_SZ: {
15796                                 {
15797                                         uint32_t _flags_save_string_array = ndr->flags;
15798                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15799                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15800                                         ndr->flags = _flags_save_string_array;
15801                                 }
15802                         break; }
15803
15804                         default: {
15805                                 {
15806                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15807                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15808                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15809                                         ndr->flags = _flags_save_DATA_BLOB;
15810                                 }
15811                         break; }
15812
15813                 }
15814         }
15815         if (ndr_flags & NDR_BUFFERS) {
15816                 int level = ndr_push_get_switch_value(ndr, r);
15817                 switch (level) {
15818                         case REG_NONE:
15819                         break;
15820
15821                         case REG_SZ:
15822                         break;
15823
15824                         case REG_BINARY:
15825                         break;
15826
15827                         case REG_DWORD:
15828                         break;
15829
15830                         case REG_MULTI_SZ:
15831                         break;
15832
15833                         default:
15834                         break;
15835
15836                 }
15837         }
15838         return NDR_ERR_SUCCESS;
15839 }
15840
15841 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15842 {
15843         int level;
15844         level = ndr_pull_get_switch_value(ndr, r);
15845         if (ndr_flags & NDR_SCALARS) {
15846                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15847                 switch (level) {
15848                         case REG_NONE: {
15849                         break; }
15850
15851                         case REG_SZ: {
15852                                 {
15853                                         uint32_t _flags_save_string = ndr->flags;
15854                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15855                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15856                                         ndr->flags = _flags_save_string;
15857                                 }
15858                         break; }
15859
15860                         case REG_BINARY: {
15861                                 {
15862                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15863                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15864                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15865                                         ndr->flags = _flags_save_DATA_BLOB;
15866                                 }
15867                         break; }
15868
15869                         case REG_DWORD: {
15870                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15871                         break; }
15872
15873                         case REG_MULTI_SZ: {
15874                                 {
15875                                         uint32_t _flags_save_string_array = ndr->flags;
15876                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15878                                         ndr->flags = _flags_save_string_array;
15879                                 }
15880                         break; }
15881
15882                         default: {
15883                                 {
15884                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15885                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15886                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15887                                         ndr->flags = _flags_save_DATA_BLOB;
15888                                 }
15889                         break; }
15890
15891                 }
15892         }
15893         if (ndr_flags & NDR_BUFFERS) {
15894                 switch (level) {
15895                         case REG_NONE:
15896                         break;
15897
15898                         case REG_SZ:
15899                         break;
15900
15901                         case REG_BINARY:
15902                         break;
15903
15904                         case REG_DWORD:
15905                         break;
15906
15907                         case REG_MULTI_SZ:
15908                         break;
15909
15910                         default:
15911                         break;
15912
15913                 }
15914         }
15915         return NDR_ERR_SUCCESS;
15916 }
15917
15918 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15919 {
15920         int level;
15921         level = ndr_print_get_switch_value(ndr, r);
15922         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15923         switch (level) {
15924                 case REG_NONE:
15925                 break;
15926
15927                 case REG_SZ:
15928                         ndr_print_string(ndr, "string", r->string);
15929                 break;
15930
15931                 case REG_BINARY:
15932                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15933                 break;
15934
15935                 case REG_DWORD:
15936                         ndr_print_uint32(ndr, "value", r->value);
15937                 break;
15938
15939                 case REG_MULTI_SZ:
15940                         ndr_print_string_array(ndr, "string_array", r->string_array);
15941                 break;
15942
15943                 default:
15944                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15945                 break;
15946
15947         }
15948 }
15949
15950 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15951 {
15952         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15953         return NDR_ERR_SUCCESS;
15954 }
15955
15956 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15957 {
15958         uint32_t v;
15959         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15960         *r = v;
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15965 {
15966         const char *val = NULL;
15967
15968         switch (r) {
15969                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15970                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15971                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15972         }
15973         ndr_print_enum(ndr, name, "ENUM", val, r);
15974 }
15975
15976 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15977 {
15978         if (ndr_flags & NDR_SCALARS) {
15979                 NDR_CHECK(ndr_push_align(ndr, 4));
15980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15982                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15983         }
15984         if (ndr_flags & NDR_BUFFERS) {
15985         }
15986         return NDR_ERR_SUCCESS;
15987 }
15988
15989 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15990 {
15991         if (ndr_flags & NDR_SCALARS) {
15992                 NDR_CHECK(ndr_pull_align(ndr, 4));
15993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15995                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15996         }
15997         if (ndr_flags & NDR_BUFFERS) {
15998         }
15999         return NDR_ERR_SUCCESS;
16000 }
16001
16002 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16003 {
16004         ndr_print_struct(ndr, name, "spoolss_FormSize");
16005         ndr->depth++;
16006         ndr_print_uint32(ndr, "width", r->width);
16007         ndr_print_uint32(ndr, "height", r->height);
16008         ndr->depth--;
16009 }
16010
16011 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16012 {
16013         if (ndr_flags & NDR_SCALARS) {
16014                 NDR_CHECK(ndr_push_align(ndr, 4));
16015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16019                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16020         }
16021         if (ndr_flags & NDR_BUFFERS) {
16022         }
16023         return NDR_ERR_SUCCESS;
16024 }
16025
16026 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16027 {
16028         if (ndr_flags & NDR_SCALARS) {
16029                 NDR_CHECK(ndr_pull_align(ndr, 4));
16030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16034                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16035         }
16036         if (ndr_flags & NDR_BUFFERS) {
16037         }
16038         return NDR_ERR_SUCCESS;
16039 }
16040
16041 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16042 {
16043         ndr_print_struct(ndr, name, "spoolss_FormArea");
16044         ndr->depth++;
16045         ndr_print_uint32(ndr, "left", r->left);
16046         ndr_print_uint32(ndr, "top", r->top);
16047         ndr_print_uint32(ndr, "right", r->right);
16048         ndr_print_uint32(ndr, "bottom", r->bottom);
16049         ndr->depth--;
16050 }
16051
16052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16053 {
16054         if (ndr_flags & NDR_SCALARS) {
16055                 NDR_CHECK(ndr_push_align(ndr, 5));
16056                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16057                 {
16058                         uint32_t _flags_save_string = ndr->flags;
16059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16060                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16061                         ndr->flags = _flags_save_string;
16062                 }
16063                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16064                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16065                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16066         }
16067         if (ndr_flags & NDR_BUFFERS) {
16068                 {
16069                         uint32_t _flags_save_string = ndr->flags;
16070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16071                         if (r->form_name) {
16072                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
16073                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16074                         }
16075                         ndr->flags = _flags_save_string;
16076                 }
16077         }
16078         return NDR_ERR_SUCCESS;
16079 }
16080
16081 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16082 {
16083         uint32_t _ptr_form_name;
16084         TALLOC_CTX *_mem_save_form_name_0;
16085         if (ndr_flags & NDR_SCALARS) {
16086                 NDR_CHECK(ndr_pull_align(ndr, 5));
16087                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16088                 {
16089                         uint32_t _flags_save_string = ndr->flags;
16090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16091                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16092                         if (_ptr_form_name) {
16093                                 NDR_PULL_ALLOC(ndr, r->form_name);
16094                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16095                         } else {
16096                                 r->form_name = NULL;
16097                         }
16098                         ndr->flags = _flags_save_string;
16099                 }
16100                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16101                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16102                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16103         }
16104         if (ndr_flags & NDR_BUFFERS) {
16105                 {
16106                         uint32_t _flags_save_string = ndr->flags;
16107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16108                         if (r->form_name) {
16109                                 uint32_t _relative_save_offset;
16110                                 _relative_save_offset = ndr->offset;
16111                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16112                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16113                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16114                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16115                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16116                                 if (ndr->offset > ndr->relative_highest_offset) {
16117                                         ndr->relative_highest_offset = ndr->offset;
16118                                 }
16119                                 ndr->offset = _relative_save_offset;
16120                         }
16121                         ndr->flags = _flags_save_string;
16122                 }
16123         }
16124         return NDR_ERR_SUCCESS;
16125 }
16126
16127 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16128 {
16129         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16130         ndr->depth++;
16131         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16132         ndr_print_ptr(ndr, "form_name", r->form_name);
16133         ndr->depth++;
16134         if (r->form_name) {
16135                 ndr_print_string(ndr, "form_name", r->form_name);
16136         }
16137         ndr->depth--;
16138         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16139         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16140         ndr->depth--;
16141 }
16142
16143 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16144 {
16145         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16146 }
16147
16148 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16149 {
16150         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16151         return NDR_ERR_SUCCESS;
16152 }
16153
16154 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16155 {
16156         uint32_t v;
16157         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16158         *r = v;
16159         return NDR_ERR_SUCCESS;
16160 }
16161
16162 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16163 {
16164         ndr_print_uint32(ndr, name, r);
16165         ndr->depth++;
16166         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16167         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16168         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16169         ndr->depth--;
16170 }
16171
16172 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16173 {
16174         if (ndr_flags & NDR_SCALARS) {
16175                 NDR_CHECK(ndr_push_align(ndr, 5));
16176                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16177                 {
16178                         uint32_t _flags_save_string = ndr->flags;
16179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16180                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16181                         ndr->flags = _flags_save_string;
16182                 }
16183                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16184                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16185                 {
16186                         uint32_t _flags_save_string = ndr->flags;
16187                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16188                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16189                         ndr->flags = _flags_save_string;
16190                 }
16191                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16192                 {
16193                         uint32_t _flags_save_string = ndr->flags;
16194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16195                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16196                         ndr->flags = _flags_save_string;
16197                 }
16198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16199                 {
16200                         uint32_t _flags_save_string = ndr->flags;
16201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16202                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16203                         ndr->flags = _flags_save_string;
16204                 }
16205                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16206                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16207                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16208         }
16209         if (ndr_flags & NDR_BUFFERS) {
16210                 {
16211                         uint32_t _flags_save_string = ndr->flags;
16212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16213                         if (r->form_name) {
16214                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
16215                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16216                         }
16217                         ndr->flags = _flags_save_string;
16218                 }
16219                 {
16220                         uint32_t _flags_save_string = ndr->flags;
16221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16222                         if (r->keyword) {
16223                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
16224                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16225                         }
16226                         ndr->flags = _flags_save_string;
16227                 }
16228                 {
16229                         uint32_t _flags_save_string = ndr->flags;
16230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16231                         if (r->mui_dll) {
16232                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
16233                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16234                         }
16235                         ndr->flags = _flags_save_string;
16236                 }
16237                 {
16238                         uint32_t _flags_save_string = ndr->flags;
16239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16240                         if (r->display_name) {
16241                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
16242                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16243                         }
16244                         ndr->flags = _flags_save_string;
16245                 }
16246         }
16247         return NDR_ERR_SUCCESS;
16248 }
16249
16250 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16251 {
16252         uint32_t _ptr_form_name;
16253         TALLOC_CTX *_mem_save_form_name_0;
16254         uint32_t _ptr_keyword;
16255         TALLOC_CTX *_mem_save_keyword_0;
16256         uint32_t _ptr_mui_dll;
16257         TALLOC_CTX *_mem_save_mui_dll_0;
16258         uint32_t _ptr_display_name;
16259         TALLOC_CTX *_mem_save_display_name_0;
16260         if (ndr_flags & NDR_SCALARS) {
16261                 NDR_CHECK(ndr_pull_align(ndr, 5));
16262                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16263                 {
16264                         uint32_t _flags_save_string = ndr->flags;
16265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16267                         if (_ptr_form_name) {
16268                                 NDR_PULL_ALLOC(ndr, r->form_name);
16269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16270                         } else {
16271                                 r->form_name = NULL;
16272                         }
16273                         ndr->flags = _flags_save_string;
16274                 }
16275                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16276                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16277                 {
16278                         uint32_t _flags_save_string = ndr->flags;
16279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16280                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16281                         if (_ptr_keyword) {
16282                                 NDR_PULL_ALLOC(ndr, r->keyword);
16283                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16284                         } else {
16285                                 r->keyword = NULL;
16286                         }
16287                         ndr->flags = _flags_save_string;
16288                 }
16289                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16290                 {
16291                         uint32_t _flags_save_string = ndr->flags;
16292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16294                         if (_ptr_mui_dll) {
16295                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16297                         } else {
16298                                 r->mui_dll = NULL;
16299                         }
16300                         ndr->flags = _flags_save_string;
16301                 }
16302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16303                 {
16304                         uint32_t _flags_save_string = ndr->flags;
16305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16306                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16307                         if (_ptr_display_name) {
16308                                 NDR_PULL_ALLOC(ndr, r->display_name);
16309                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16310                         } else {
16311                                 r->display_name = NULL;
16312                         }
16313                         ndr->flags = _flags_save_string;
16314                 }
16315                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16316                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16317                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16318         }
16319         if (ndr_flags & NDR_BUFFERS) {
16320                 {
16321                         uint32_t _flags_save_string = ndr->flags;
16322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16323                         if (r->form_name) {
16324                                 uint32_t _relative_save_offset;
16325                                 _relative_save_offset = ndr->offset;
16326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16327                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16328                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16331                                 if (ndr->offset > ndr->relative_highest_offset) {
16332                                         ndr->relative_highest_offset = ndr->offset;
16333                                 }
16334                                 ndr->offset = _relative_save_offset;
16335                         }
16336                         ndr->flags = _flags_save_string;
16337                 }
16338                 {
16339                         uint32_t _flags_save_string = ndr->flags;
16340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16341                         if (r->keyword) {
16342                                 uint32_t _relative_save_offset;
16343                                 _relative_save_offset = ndr->offset;
16344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16345                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16346                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16349                                 if (ndr->offset > ndr->relative_highest_offset) {
16350                                         ndr->relative_highest_offset = ndr->offset;
16351                                 }
16352                                 ndr->offset = _relative_save_offset;
16353                         }
16354                         ndr->flags = _flags_save_string;
16355                 }
16356                 {
16357                         uint32_t _flags_save_string = ndr->flags;
16358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16359                         if (r->mui_dll) {
16360                                 uint32_t _relative_save_offset;
16361                                 _relative_save_offset = ndr->offset;
16362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16363                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16364                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16367                                 if (ndr->offset > ndr->relative_highest_offset) {
16368                                         ndr->relative_highest_offset = ndr->offset;
16369                                 }
16370                                 ndr->offset = _relative_save_offset;
16371                         }
16372                         ndr->flags = _flags_save_string;
16373                 }
16374                 {
16375                         uint32_t _flags_save_string = ndr->flags;
16376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16377                         if (r->display_name) {
16378                                 uint32_t _relative_save_offset;
16379                                 _relative_save_offset = ndr->offset;
16380                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16381                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16382                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16383                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16384                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16385                                 if (ndr->offset > ndr->relative_highest_offset) {
16386                                         ndr->relative_highest_offset = ndr->offset;
16387                                 }
16388                                 ndr->offset = _relative_save_offset;
16389                         }
16390                         ndr->flags = _flags_save_string;
16391                 }
16392         }
16393         return NDR_ERR_SUCCESS;
16394 }
16395
16396 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16397 {
16398         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16399         ndr->depth++;
16400         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16401         ndr_print_ptr(ndr, "form_name", r->form_name);
16402         ndr->depth++;
16403         if (r->form_name) {
16404                 ndr_print_string(ndr, "form_name", r->form_name);
16405         }
16406         ndr->depth--;
16407         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16408         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16409         ndr_print_ptr(ndr, "keyword", r->keyword);
16410         ndr->depth++;
16411         if (r->keyword) {
16412                 ndr_print_string(ndr, "keyword", r->keyword);
16413         }
16414         ndr->depth--;
16415         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16416         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16417         ndr->depth++;
16418         if (r->mui_dll) {
16419                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16420         }
16421         ndr->depth--;
16422         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16423         ndr_print_ptr(ndr, "display_name", r->display_name);
16424         ndr->depth++;
16425         if (r->display_name) {
16426                 ndr_print_string(ndr, "display_name", r->display_name);
16427         }
16428         ndr->depth--;
16429         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16430         ndr_print_uint16(ndr, "unused", r->unused);
16431         ndr->depth--;
16432 }
16433
16434 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16435 {
16436         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16437 }
16438
16439 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16440 {
16441         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16442         if (ndr_flags & NDR_SCALARS) {
16443                 int level = ndr_push_get_switch_value(ndr, r);
16444                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16445                 switch (level) {
16446                         case 1: {
16447                                 NDR_CHECK(ndr_push_align(ndr, 5));
16448                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16449                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16450                         break; }
16451
16452                         case 2: {
16453                                 NDR_CHECK(ndr_push_align(ndr, 5));
16454                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16455                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16456                         break; }
16457
16458                         default: {
16459                         break; }
16460
16461                 }
16462         }
16463         if (ndr_flags & NDR_BUFFERS) {
16464                 int level = ndr_push_get_switch_value(ndr, r);
16465                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16466                 switch (level) {
16467                         case 1:
16468                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16469                         break;
16470
16471                         case 2:
16472                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16473                         break;
16474
16475                         default:
16476                         break;
16477
16478                 }
16479         }
16480         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16481         return NDR_ERR_SUCCESS;
16482 }
16483
16484 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16485 {
16486         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16487         int level;
16488         level = ndr_pull_get_switch_value(ndr, r);
16489         if (ndr_flags & NDR_SCALARS) {
16490                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16491                 switch (level) {
16492                         case 1: {
16493                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16494                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16495                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16496                         break; }
16497
16498                         case 2: {
16499                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16500                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16501                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16502                         break; }
16503
16504                         default: {
16505                         break; }
16506
16507                 }
16508         }
16509         if (ndr_flags & NDR_BUFFERS) {
16510                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16511                 switch (level) {
16512                         case 1:
16513                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16514                         break;
16515
16516                         case 2:
16517                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16518                         break;
16519
16520                         default:
16521                         break;
16522
16523                 }
16524         }
16525         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16526         return NDR_ERR_SUCCESS;
16527 }
16528
16529 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16530 {
16531         int level;
16532         level = ndr_print_get_switch_value(ndr, r);
16533         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16534         switch (level) {
16535                 case 1:
16536                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16537                 break;
16538
16539                 case 2:
16540                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16541                 break;
16542
16543                 default:
16544                 break;
16545
16546         }
16547 }
16548
16549 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16550 {
16551         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16552 }
16553
16554 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16555 {
16556         if (ndr_flags & NDR_SCALARS) {
16557                 NDR_CHECK(ndr_push_align(ndr, 5));
16558                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16560                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16561                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16562                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16563         }
16564         if (ndr_flags & NDR_BUFFERS) {
16565                 if (r->form_name) {
16566                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16567                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16569                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16570                 }
16571         }
16572         return NDR_ERR_SUCCESS;
16573 }
16574
16575 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16576 {
16577         uint32_t _ptr_form_name;
16578         TALLOC_CTX *_mem_save_form_name_0;
16579         if (ndr_flags & NDR_SCALARS) {
16580                 NDR_CHECK(ndr_pull_align(ndr, 5));
16581                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16583                 if (_ptr_form_name) {
16584                         NDR_PULL_ALLOC(ndr, r->form_name);
16585                 } else {
16586                         r->form_name = NULL;
16587                 }
16588                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16589                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16590                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16591         }
16592         if (ndr_flags & NDR_BUFFERS) {
16593                 if (r->form_name) {
16594                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16595                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16598                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16599                                 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));
16600                         }
16601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16604                 }
16605         }
16606         return NDR_ERR_SUCCESS;
16607 }
16608
16609 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16610 {
16611         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16612         ndr->depth++;
16613         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16614         ndr_print_ptr(ndr, "form_name", r->form_name);
16615         ndr->depth++;
16616         if (r->form_name) {
16617                 ndr_print_string(ndr, "form_name", r->form_name);
16618         }
16619         ndr->depth--;
16620         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16621         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16622         ndr->depth--;
16623 }
16624
16625 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16626 {
16627         if (ndr_flags & NDR_SCALARS) {
16628                 NDR_CHECK(ndr_push_align(ndr, 5));
16629                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16631                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16632                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16634                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16639                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16640         }
16641         if (ndr_flags & NDR_BUFFERS) {
16642                 if (r->form_name) {
16643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16646                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16647                 }
16648                 if (r->keyword) {
16649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16652                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16653                 }
16654                 if (r->mui_dll) {
16655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16659                 }
16660                 if (r->display_name) {
16661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16665                 }
16666         }
16667         return NDR_ERR_SUCCESS;
16668 }
16669
16670 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16671 {
16672         uint32_t _ptr_form_name;
16673         TALLOC_CTX *_mem_save_form_name_0;
16674         uint32_t _ptr_keyword;
16675         TALLOC_CTX *_mem_save_keyword_0;
16676         uint32_t _ptr_mui_dll;
16677         TALLOC_CTX *_mem_save_mui_dll_0;
16678         uint32_t _ptr_display_name;
16679         TALLOC_CTX *_mem_save_display_name_0;
16680         if (ndr_flags & NDR_SCALARS) {
16681                 NDR_CHECK(ndr_pull_align(ndr, 5));
16682                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16684                 if (_ptr_form_name) {
16685                         NDR_PULL_ALLOC(ndr, r->form_name);
16686                 } else {
16687                         r->form_name = NULL;
16688                 }
16689                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16690                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16691                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16692                 if (_ptr_keyword) {
16693                         NDR_PULL_ALLOC(ndr, r->keyword);
16694                 } else {
16695                         r->keyword = NULL;
16696                 }
16697                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16699                 if (_ptr_mui_dll) {
16700                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16701                 } else {
16702                         r->mui_dll = NULL;
16703                 }
16704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16705                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16706                 if (_ptr_display_name) {
16707                         NDR_PULL_ALLOC(ndr, r->display_name);
16708                 } else {
16709                         r->display_name = NULL;
16710                 }
16711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16712                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16713         }
16714         if (ndr_flags & NDR_BUFFERS) {
16715                 if (r->form_name) {
16716                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16717                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16718                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16719                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16720                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16721                                 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));
16722                         }
16723                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16724                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16726                 }
16727                 if (r->keyword) {
16728                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16729                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16730                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16731                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16732                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16733                                 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));
16734                         }
16735                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16736                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16737                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16738                 }
16739                 if (r->mui_dll) {
16740                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16741                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16744                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16745                                 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));
16746                         }
16747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16750                 }
16751                 if (r->display_name) {
16752                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16753                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16754                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16755                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16756                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16757                                 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));
16758                         }
16759                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16760                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16762                 }
16763         }
16764         return NDR_ERR_SUCCESS;
16765 }
16766
16767 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16768 {
16769         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16770         ndr->depth++;
16771         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16772         ndr_print_ptr(ndr, "form_name", r->form_name);
16773         ndr->depth++;
16774         if (r->form_name) {
16775                 ndr_print_string(ndr, "form_name", r->form_name);
16776         }
16777         ndr->depth--;
16778         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16779         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16780         ndr_print_ptr(ndr, "keyword", r->keyword);
16781         ndr->depth++;
16782         if (r->keyword) {
16783                 ndr_print_string(ndr, "keyword", r->keyword);
16784         }
16785         ndr->depth--;
16786         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16787         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16788         ndr->depth++;
16789         if (r->mui_dll) {
16790                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16791         }
16792         ndr->depth--;
16793         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16794         ndr_print_ptr(ndr, "display_name", r->display_name);
16795         ndr->depth++;
16796         if (r->display_name) {
16797                 ndr_print_string(ndr, "display_name", r->display_name);
16798         }
16799         ndr->depth--;
16800         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16801         ndr->depth--;
16802 }
16803
16804 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16805 {
16806         if (ndr_flags & NDR_SCALARS) {
16807                 int level = ndr_push_get_switch_value(ndr, r);
16808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16809                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16810                 switch (level) {
16811                         case 1: {
16812                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16813                         break; }
16814
16815                         case 2: {
16816                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16817                         break; }
16818
16819                         default:
16820                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16821                 }
16822         }
16823         if (ndr_flags & NDR_BUFFERS) {
16824                 int level = ndr_push_get_switch_value(ndr, r);
16825                 switch (level) {
16826                         case 1:
16827                                 if (r->info1) {
16828                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16829                                 }
16830                         break;
16831
16832                         case 2:
16833                                 if (r->info2) {
16834                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16835                                 }
16836                         break;
16837
16838                         default:
16839                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16840                 }
16841         }
16842         return NDR_ERR_SUCCESS;
16843 }
16844
16845 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16846 {
16847         int level;
16848         uint32_t _level;
16849         TALLOC_CTX *_mem_save_info1_0;
16850         TALLOC_CTX *_mem_save_info2_0;
16851         level = ndr_pull_get_switch_value(ndr, r);
16852         if (ndr_flags & NDR_SCALARS) {
16853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16854                 if (_level != level) {
16855                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16856                 }
16857                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16858                 switch (level) {
16859                         case 1: {
16860                                 uint32_t _ptr_info1;
16861                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16862                                 if (_ptr_info1) {
16863                                         NDR_PULL_ALLOC(ndr, r->info1);
16864                                 } else {
16865                                         r->info1 = NULL;
16866                                 }
16867                         break; }
16868
16869                         case 2: {
16870                                 uint32_t _ptr_info2;
16871                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16872                                 if (_ptr_info2) {
16873                                         NDR_PULL_ALLOC(ndr, r->info2);
16874                                 } else {
16875                                         r->info2 = NULL;
16876                                 }
16877                         break; }
16878
16879                         default:
16880                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16881                 }
16882         }
16883         if (ndr_flags & NDR_BUFFERS) {
16884                 switch (level) {
16885                         case 1:
16886                                 if (r->info1) {
16887                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16888                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16889                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16890                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16891                                 }
16892                         break;
16893
16894                         case 2:
16895                                 if (r->info2) {
16896                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16897                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16898                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16899                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16900                                 }
16901                         break;
16902
16903                         default:
16904                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16905                 }
16906         }
16907         return NDR_ERR_SUCCESS;
16908 }
16909
16910 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16911 {
16912         int level;
16913         level = ndr_print_get_switch_value(ndr, r);
16914         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16915         switch (level) {
16916                 case 1:
16917                         ndr_print_ptr(ndr, "info1", r->info1);
16918                         ndr->depth++;
16919                         if (r->info1) {
16920                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16921                         }
16922                         ndr->depth--;
16923                 break;
16924
16925                 case 2:
16926                         ndr_print_ptr(ndr, "info2", r->info2);
16927                         ndr->depth++;
16928                         if (r->info2) {
16929                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16930                         }
16931                         ndr->depth--;
16932                 break;
16933
16934                 default:
16935                         ndr_print_bad_level(ndr, name, level);
16936         }
16937 }
16938
16939 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16940 {
16941         if (ndr_flags & NDR_SCALARS) {
16942                 NDR_CHECK(ndr_push_align(ndr, 5));
16943                 {
16944                         uint32_t _flags_save_string = ndr->flags;
16945                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16946                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16947                         ndr->flags = _flags_save_string;
16948                 }
16949                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16950         }
16951         if (ndr_flags & NDR_BUFFERS) {
16952                 {
16953                         uint32_t _flags_save_string = ndr->flags;
16954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16955                         if (r->port_name) {
16956                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16957                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16958                         }
16959                         ndr->flags = _flags_save_string;
16960                 }
16961         }
16962         return NDR_ERR_SUCCESS;
16963 }
16964
16965 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16966 {
16967         uint32_t _ptr_port_name;
16968         TALLOC_CTX *_mem_save_port_name_0;
16969         if (ndr_flags & NDR_SCALARS) {
16970                 NDR_CHECK(ndr_pull_align(ndr, 5));
16971                 {
16972                         uint32_t _flags_save_string = ndr->flags;
16973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16974                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16975                         if (_ptr_port_name) {
16976                                 NDR_PULL_ALLOC(ndr, r->port_name);
16977                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16978                         } else {
16979                                 r->port_name = NULL;
16980                         }
16981                         ndr->flags = _flags_save_string;
16982                 }
16983                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16984         }
16985         if (ndr_flags & NDR_BUFFERS) {
16986                 {
16987                         uint32_t _flags_save_string = ndr->flags;
16988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16989                         if (r->port_name) {
16990                                 uint32_t _relative_save_offset;
16991                                 _relative_save_offset = ndr->offset;
16992                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16993                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16994                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16995                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16996                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16997                                 if (ndr->offset > ndr->relative_highest_offset) {
16998                                         ndr->relative_highest_offset = ndr->offset;
16999                                 }
17000                                 ndr->offset = _relative_save_offset;
17001                         }
17002                         ndr->flags = _flags_save_string;
17003                 }
17004         }
17005         return NDR_ERR_SUCCESS;
17006 }
17007
17008 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17009 {
17010         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17011         ndr->depth++;
17012         ndr_print_ptr(ndr, "port_name", r->port_name);
17013         ndr->depth++;
17014         if (r->port_name) {
17015                 ndr_print_string(ndr, "port_name", r->port_name);
17016         }
17017         ndr->depth--;
17018         ndr->depth--;
17019 }
17020
17021 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17022 {
17023         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17024 }
17025
17026 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17027 {
17028         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17029         return NDR_ERR_SUCCESS;
17030 }
17031
17032 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17033 {
17034         uint32_t v;
17035         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17036         *r = v;
17037         return NDR_ERR_SUCCESS;
17038 }
17039
17040 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17041 {
17042         ndr_print_uint32(ndr, name, r);
17043         ndr->depth++;
17044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17045         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17046         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17047         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17048         ndr->depth--;
17049 }
17050
17051 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17052 {
17053         if (ndr_flags & NDR_SCALARS) {
17054                 NDR_CHECK(ndr_push_align(ndr, 5));
17055                 {
17056                         uint32_t _flags_save_string = ndr->flags;
17057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17058                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17059                         ndr->flags = _flags_save_string;
17060                 }
17061                 {
17062                         uint32_t _flags_save_string = ndr->flags;
17063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17064                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17065                         ndr->flags = _flags_save_string;
17066                 }
17067                 {
17068                         uint32_t _flags_save_string = ndr->flags;
17069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17071                         ndr->flags = _flags_save_string;
17072                 }
17073                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17075                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17076         }
17077         if (ndr_flags & NDR_BUFFERS) {
17078                 {
17079                         uint32_t _flags_save_string = ndr->flags;
17080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17081                         if (r->port_name) {
17082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17084                         }
17085                         ndr->flags = _flags_save_string;
17086                 }
17087                 {
17088                         uint32_t _flags_save_string = ndr->flags;
17089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17090                         if (r->monitor_name) {
17091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17093                         }
17094                         ndr->flags = _flags_save_string;
17095                 }
17096                 {
17097                         uint32_t _flags_save_string = ndr->flags;
17098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17099                         if (r->description) {
17100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
17101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17102                         }
17103                         ndr->flags = _flags_save_string;
17104                 }
17105         }
17106         return NDR_ERR_SUCCESS;
17107 }
17108
17109 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17110 {
17111         uint32_t _ptr_port_name;
17112         TALLOC_CTX *_mem_save_port_name_0;
17113         uint32_t _ptr_monitor_name;
17114         TALLOC_CTX *_mem_save_monitor_name_0;
17115         uint32_t _ptr_description;
17116         TALLOC_CTX *_mem_save_description_0;
17117         if (ndr_flags & NDR_SCALARS) {
17118                 NDR_CHECK(ndr_pull_align(ndr, 5));
17119                 {
17120                         uint32_t _flags_save_string = ndr->flags;
17121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17122                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17123                         if (_ptr_port_name) {
17124                                 NDR_PULL_ALLOC(ndr, r->port_name);
17125                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17126                         } else {
17127                                 r->port_name = NULL;
17128                         }
17129                         ndr->flags = _flags_save_string;
17130                 }
17131                 {
17132                         uint32_t _flags_save_string = ndr->flags;
17133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17134                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17135                         if (_ptr_monitor_name) {
17136                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17137                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17138                         } else {
17139                                 r->monitor_name = NULL;
17140                         }
17141                         ndr->flags = _flags_save_string;
17142                 }
17143                 {
17144                         uint32_t _flags_save_string = ndr->flags;
17145                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17146                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17147                         if (_ptr_description) {
17148                                 NDR_PULL_ALLOC(ndr, r->description);
17149                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17150                         } else {
17151                                 r->description = NULL;
17152                         }
17153                         ndr->flags = _flags_save_string;
17154                 }
17155                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17157                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17158         }
17159         if (ndr_flags & NDR_BUFFERS) {
17160                 {
17161                         uint32_t _flags_save_string = ndr->flags;
17162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17163                         if (r->port_name) {
17164                                 uint32_t _relative_save_offset;
17165                                 _relative_save_offset = ndr->offset;
17166                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17167                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17168                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17169                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17170                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17171                                 if (ndr->offset > ndr->relative_highest_offset) {
17172                                         ndr->relative_highest_offset = ndr->offset;
17173                                 }
17174                                 ndr->offset = _relative_save_offset;
17175                         }
17176                         ndr->flags = _flags_save_string;
17177                 }
17178                 {
17179                         uint32_t _flags_save_string = ndr->flags;
17180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17181                         if (r->monitor_name) {
17182                                 uint32_t _relative_save_offset;
17183                                 _relative_save_offset = ndr->offset;
17184                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17185                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17186                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17187                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17188                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17189                                 if (ndr->offset > ndr->relative_highest_offset) {
17190                                         ndr->relative_highest_offset = ndr->offset;
17191                                 }
17192                                 ndr->offset = _relative_save_offset;
17193                         }
17194                         ndr->flags = _flags_save_string;
17195                 }
17196                 {
17197                         uint32_t _flags_save_string = ndr->flags;
17198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17199                         if (r->description) {
17200                                 uint32_t _relative_save_offset;
17201                                 _relative_save_offset = ndr->offset;
17202                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17203                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17204                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17205                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17206                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17207                                 if (ndr->offset > ndr->relative_highest_offset) {
17208                                         ndr->relative_highest_offset = ndr->offset;
17209                                 }
17210                                 ndr->offset = _relative_save_offset;
17211                         }
17212                         ndr->flags = _flags_save_string;
17213                 }
17214         }
17215         return NDR_ERR_SUCCESS;
17216 }
17217
17218 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17219 {
17220         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17221         ndr->depth++;
17222         ndr_print_ptr(ndr, "port_name", r->port_name);
17223         ndr->depth++;
17224         if (r->port_name) {
17225                 ndr_print_string(ndr, "port_name", r->port_name);
17226         }
17227         ndr->depth--;
17228         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17229         ndr->depth++;
17230         if (r->monitor_name) {
17231                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17232         }
17233         ndr->depth--;
17234         ndr_print_ptr(ndr, "description", r->description);
17235         ndr->depth++;
17236         if (r->description) {
17237                 ndr_print_string(ndr, "description", r->description);
17238         }
17239         ndr->depth--;
17240         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17241         ndr_print_uint32(ndr, "reserved", r->reserved);
17242         ndr->depth--;
17243 }
17244
17245 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17246 {
17247         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17248 }
17249
17250 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17251 {
17252         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17253         return NDR_ERR_SUCCESS;
17254 }
17255
17256 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17257 {
17258         uint32_t v;
17259         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17260         *r = v;
17261         return NDR_ERR_SUCCESS;
17262 }
17263
17264 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17265 {
17266         const char *val = NULL;
17267
17268         switch (r) {
17269                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17270                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17271                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17272                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17273                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17274                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17275                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17276                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17277                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17278                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17279                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17280                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17281                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17282         }
17283         ndr_print_enum(ndr, name, "ENUM", val, r);
17284 }
17285
17286 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17287 {
17288         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17289         return NDR_ERR_SUCCESS;
17290 }
17291
17292 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17293 {
17294         uint32_t v;
17295         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17296         *r = v;
17297         return NDR_ERR_SUCCESS;
17298 }
17299
17300 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17301 {
17302         const char *val = NULL;
17303
17304         switch (r) {
17305                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17306                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17307                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17308         }
17309         ndr_print_enum(ndr, name, "ENUM", val, r);
17310 }
17311
17312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17313 {
17314         if (ndr_flags & NDR_SCALARS) {
17315                 NDR_CHECK(ndr_push_align(ndr, 5));
17316                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17317                 {
17318                         uint32_t _flags_save_string = ndr->flags;
17319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17321                         ndr->flags = _flags_save_string;
17322                 }
17323                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17324                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17325         }
17326         if (ndr_flags & NDR_BUFFERS) {
17327                 {
17328                         uint32_t _flags_save_string = ndr->flags;
17329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17330                         if (r->status_string) {
17331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
17332                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17333                         }
17334                         ndr->flags = _flags_save_string;
17335                 }
17336         }
17337         return NDR_ERR_SUCCESS;
17338 }
17339
17340 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17341 {
17342         uint32_t _ptr_status_string;
17343         TALLOC_CTX *_mem_save_status_string_0;
17344         if (ndr_flags & NDR_SCALARS) {
17345                 NDR_CHECK(ndr_pull_align(ndr, 5));
17346                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17347                 {
17348                         uint32_t _flags_save_string = ndr->flags;
17349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17350                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17351                         if (_ptr_status_string) {
17352                                 NDR_PULL_ALLOC(ndr, r->status_string);
17353                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17354                         } else {
17355                                 r->status_string = NULL;
17356                         }
17357                         ndr->flags = _flags_save_string;
17358                 }
17359                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17360                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17361         }
17362         if (ndr_flags & NDR_BUFFERS) {
17363                 {
17364                         uint32_t _flags_save_string = ndr->flags;
17365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17366                         if (r->status_string) {
17367                                 uint32_t _relative_save_offset;
17368                                 _relative_save_offset = ndr->offset;
17369                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17370                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17371                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17372                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17373                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17374                                 if (ndr->offset > ndr->relative_highest_offset) {
17375                                         ndr->relative_highest_offset = ndr->offset;
17376                                 }
17377                                 ndr->offset = _relative_save_offset;
17378                         }
17379                         ndr->flags = _flags_save_string;
17380                 }
17381         }
17382         return NDR_ERR_SUCCESS;
17383 }
17384
17385 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17386 {
17387         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17388         ndr->depth++;
17389         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17390         ndr_print_ptr(ndr, "status_string", r->status_string);
17391         ndr->depth++;
17392         if (r->status_string) {
17393                 ndr_print_string(ndr, "status_string", r->status_string);
17394         }
17395         ndr->depth--;
17396         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17397         ndr->depth--;
17398 }
17399
17400 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17401 {
17402         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17403 }
17404
17405 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17406 {
17407         if (ndr_flags & NDR_SCALARS) {
17408                 NDR_CHECK(ndr_push_align(ndr, 5));
17409                 {
17410                         uint32_t _flags_save_string = ndr->flags;
17411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17412                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17413                         ndr->flags = _flags_save_string;
17414                 }
17415                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17416                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17417         }
17418         if (ndr_flags & NDR_BUFFERS) {
17419                 {
17420                         uint32_t _flags_save_string = ndr->flags;
17421                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17422                         if (r->port_name) {
17423                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17424                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17425                         }
17426                         ndr->flags = _flags_save_string;
17427                 }
17428         }
17429         return NDR_ERR_SUCCESS;
17430 }
17431
17432 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17433 {
17434         uint32_t _ptr_port_name;
17435         TALLOC_CTX *_mem_save_port_name_0;
17436         if (ndr_flags & NDR_SCALARS) {
17437                 NDR_CHECK(ndr_pull_align(ndr, 5));
17438                 {
17439                         uint32_t _flags_save_string = ndr->flags;
17440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17441                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17442                         if (_ptr_port_name) {
17443                                 NDR_PULL_ALLOC(ndr, r->port_name);
17444                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17445                         } else {
17446                                 r->port_name = NULL;
17447                         }
17448                         ndr->flags = _flags_save_string;
17449                 }
17450                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17451                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17452         }
17453         if (ndr_flags & NDR_BUFFERS) {
17454                 {
17455                         uint32_t _flags_save_string = ndr->flags;
17456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17457                         if (r->port_name) {
17458                                 uint32_t _relative_save_offset;
17459                                 _relative_save_offset = ndr->offset;
17460                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17461                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17462                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17463                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17464                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17465                                 if (ndr->offset > ndr->relative_highest_offset) {
17466                                         ndr->relative_highest_offset = ndr->offset;
17467                                 }
17468                                 ndr->offset = _relative_save_offset;
17469                         }
17470                         ndr->flags = _flags_save_string;
17471                 }
17472         }
17473         return NDR_ERR_SUCCESS;
17474 }
17475
17476 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17477 {
17478         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17479         ndr->depth++;
17480         ndr_print_ptr(ndr, "port_name", r->port_name);
17481         ndr->depth++;
17482         if (r->port_name) {
17483                 ndr_print_string(ndr, "port_name", r->port_name);
17484         }
17485         ndr->depth--;
17486         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17487         ndr->depth--;
17488 }
17489
17490 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17491 {
17492         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17493 }
17494
17495 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17496 {
17497         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17498         if (ndr_flags & NDR_SCALARS) {
17499                 int level = ndr_push_get_switch_value(ndr, r);
17500                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17501                 switch (level) {
17502                         case 1: {
17503                                 NDR_CHECK(ndr_push_align(ndr, 5));
17504                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17505                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17506                         break; }
17507
17508                         case 2: {
17509                                 NDR_CHECK(ndr_push_align(ndr, 5));
17510                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17511                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17512                         break; }
17513
17514                         case 3: {
17515                                 NDR_CHECK(ndr_push_align(ndr, 5));
17516                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17517                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17518                         break; }
17519
17520                         case 0xff: {
17521                                 NDR_CHECK(ndr_push_align(ndr, 5));
17522                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17523                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17524                         break; }
17525
17526                         default: {
17527                         break; }
17528
17529                 }
17530         }
17531         if (ndr_flags & NDR_BUFFERS) {
17532                 int level = ndr_push_get_switch_value(ndr, r);
17533                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17534                 switch (level) {
17535                         case 1:
17536                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17537                         break;
17538
17539                         case 2:
17540                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17541                         break;
17542
17543                         case 3:
17544                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17545                         break;
17546
17547                         case 0xff:
17548                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17549                         break;
17550
17551                         default:
17552                         break;
17553
17554                 }
17555         }
17556         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17557         return NDR_ERR_SUCCESS;
17558 }
17559
17560 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17561 {
17562         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17563         int level;
17564         level = ndr_pull_get_switch_value(ndr, r);
17565         if (ndr_flags & NDR_SCALARS) {
17566                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17567                 switch (level) {
17568                         case 1: {
17569                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17570                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17571                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17572                         break; }
17573
17574                         case 2: {
17575                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17576                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17577                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17578                         break; }
17579
17580                         case 3: {
17581                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17582                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17583                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17584                         break; }
17585
17586                         case 0xff: {
17587                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17588                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17589                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17590                         break; }
17591
17592                         default: {
17593                         break; }
17594
17595                 }
17596         }
17597         if (ndr_flags & NDR_BUFFERS) {
17598                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17599                 switch (level) {
17600                         case 1:
17601                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17602                         break;
17603
17604                         case 2:
17605                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17606                         break;
17607
17608                         case 3:
17609                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17610                         break;
17611
17612                         case 0xff:
17613                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17614                         break;
17615
17616                         default:
17617                         break;
17618
17619                 }
17620         }
17621         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17622         return NDR_ERR_SUCCESS;
17623 }
17624
17625 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17626 {
17627         int level;
17628         level = ndr_print_get_switch_value(ndr, r);
17629         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17630         switch (level) {
17631                 case 1:
17632                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17633                 break;
17634
17635                 case 2:
17636                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17637                 break;
17638
17639                 case 3:
17640                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17641                 break;
17642
17643                 case 0xff:
17644                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17645                 break;
17646
17647                 default:
17648                 break;
17649
17650         }
17651 }
17652
17653 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17654 {
17655         if (ndr_flags & NDR_SCALARS) {
17656                 NDR_CHECK(ndr_push_align(ndr, 5));
17657                 {
17658                         uint32_t _flags_save_string = ndr->flags;
17659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17660                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17661                         ndr->flags = _flags_save_string;
17662                 }
17663                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17664         }
17665         if (ndr_flags & NDR_BUFFERS) {
17666                 {
17667                         uint32_t _flags_save_string = ndr->flags;
17668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17669                         if (r->monitor_name) {
17670                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17671                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17672                         }
17673                         ndr->flags = _flags_save_string;
17674                 }
17675         }
17676         return NDR_ERR_SUCCESS;
17677 }
17678
17679 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17680 {
17681         uint32_t _ptr_monitor_name;
17682         TALLOC_CTX *_mem_save_monitor_name_0;
17683         if (ndr_flags & NDR_SCALARS) {
17684                 NDR_CHECK(ndr_pull_align(ndr, 5));
17685                 {
17686                         uint32_t _flags_save_string = ndr->flags;
17687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17688                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17689                         if (_ptr_monitor_name) {
17690                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17691                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17692                         } else {
17693                                 r->monitor_name = NULL;
17694                         }
17695                         ndr->flags = _flags_save_string;
17696                 }
17697                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17698         }
17699         if (ndr_flags & NDR_BUFFERS) {
17700                 {
17701                         uint32_t _flags_save_string = ndr->flags;
17702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17703                         if (r->monitor_name) {
17704                                 uint32_t _relative_save_offset;
17705                                 _relative_save_offset = ndr->offset;
17706                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17707                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17708                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17709                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17710                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17711                                 if (ndr->offset > ndr->relative_highest_offset) {
17712                                         ndr->relative_highest_offset = ndr->offset;
17713                                 }
17714                                 ndr->offset = _relative_save_offset;
17715                         }
17716                         ndr->flags = _flags_save_string;
17717                 }
17718         }
17719         return NDR_ERR_SUCCESS;
17720 }
17721
17722 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17723 {
17724         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17725         ndr->depth++;
17726         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17727         ndr->depth++;
17728         if (r->monitor_name) {
17729                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17730         }
17731         ndr->depth--;
17732         ndr->depth--;
17733 }
17734
17735 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17736 {
17737         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17738 }
17739
17740 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17741 {
17742         if (ndr_flags & NDR_SCALARS) {
17743                 NDR_CHECK(ndr_push_align(ndr, 5));
17744                 {
17745                         uint32_t _flags_save_string = ndr->flags;
17746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17747                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17748                         ndr->flags = _flags_save_string;
17749                 }
17750                 {
17751                         uint32_t _flags_save_string = ndr->flags;
17752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17753                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17754                         ndr->flags = _flags_save_string;
17755                 }
17756                 {
17757                         uint32_t _flags_save_string = ndr->flags;
17758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17760                         ndr->flags = _flags_save_string;
17761                 }
17762                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17763         }
17764         if (ndr_flags & NDR_BUFFERS) {
17765                 {
17766                         uint32_t _flags_save_string = ndr->flags;
17767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17768                         if (r->monitor_name) {
17769                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17770                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17771                         }
17772                         ndr->flags = _flags_save_string;
17773                 }
17774                 {
17775                         uint32_t _flags_save_string = ndr->flags;
17776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17777                         if (r->environment) {
17778                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17779                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17780                         }
17781                         ndr->flags = _flags_save_string;
17782                 }
17783                 {
17784                         uint32_t _flags_save_string = ndr->flags;
17785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17786                         if (r->dll_name) {
17787                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17788                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17789                         }
17790                         ndr->flags = _flags_save_string;
17791                 }
17792         }
17793         return NDR_ERR_SUCCESS;
17794 }
17795
17796 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17797 {
17798         uint32_t _ptr_monitor_name;
17799         TALLOC_CTX *_mem_save_monitor_name_0;
17800         uint32_t _ptr_environment;
17801         TALLOC_CTX *_mem_save_environment_0;
17802         uint32_t _ptr_dll_name;
17803         TALLOC_CTX *_mem_save_dll_name_0;
17804         if (ndr_flags & NDR_SCALARS) {
17805                 NDR_CHECK(ndr_pull_align(ndr, 5));
17806                 {
17807                         uint32_t _flags_save_string = ndr->flags;
17808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17809                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17810                         if (_ptr_monitor_name) {
17811                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17812                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17813                         } else {
17814                                 r->monitor_name = NULL;
17815                         }
17816                         ndr->flags = _flags_save_string;
17817                 }
17818                 {
17819                         uint32_t _flags_save_string = ndr->flags;
17820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17821                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17822                         if (_ptr_environment) {
17823                                 NDR_PULL_ALLOC(ndr, r->environment);
17824                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17825                         } else {
17826                                 r->environment = NULL;
17827                         }
17828                         ndr->flags = _flags_save_string;
17829                 }
17830                 {
17831                         uint32_t _flags_save_string = ndr->flags;
17832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17834                         if (_ptr_dll_name) {
17835                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17837                         } else {
17838                                 r->dll_name = NULL;
17839                         }
17840                         ndr->flags = _flags_save_string;
17841                 }
17842                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17843         }
17844         if (ndr_flags & NDR_BUFFERS) {
17845                 {
17846                         uint32_t _flags_save_string = ndr->flags;
17847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17848                         if (r->monitor_name) {
17849                                 uint32_t _relative_save_offset;
17850                                 _relative_save_offset = ndr->offset;
17851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17852                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17853                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17856                                 if (ndr->offset > ndr->relative_highest_offset) {
17857                                         ndr->relative_highest_offset = ndr->offset;
17858                                 }
17859                                 ndr->offset = _relative_save_offset;
17860                         }
17861                         ndr->flags = _flags_save_string;
17862                 }
17863                 {
17864                         uint32_t _flags_save_string = ndr->flags;
17865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17866                         if (r->environment) {
17867                                 uint32_t _relative_save_offset;
17868                                 _relative_save_offset = ndr->offset;
17869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17870                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17871                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17874                                 if (ndr->offset > ndr->relative_highest_offset) {
17875                                         ndr->relative_highest_offset = ndr->offset;
17876                                 }
17877                                 ndr->offset = _relative_save_offset;
17878                         }
17879                         ndr->flags = _flags_save_string;
17880                 }
17881                 {
17882                         uint32_t _flags_save_string = ndr->flags;
17883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17884                         if (r->dll_name) {
17885                                 uint32_t _relative_save_offset;
17886                                 _relative_save_offset = ndr->offset;
17887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17888                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17889                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17892                                 if (ndr->offset > ndr->relative_highest_offset) {
17893                                         ndr->relative_highest_offset = ndr->offset;
17894                                 }
17895                                 ndr->offset = _relative_save_offset;
17896                         }
17897                         ndr->flags = _flags_save_string;
17898                 }
17899         }
17900         return NDR_ERR_SUCCESS;
17901 }
17902
17903 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17904 {
17905         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17906         ndr->depth++;
17907         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17908         ndr->depth++;
17909         if (r->monitor_name) {
17910                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17911         }
17912         ndr->depth--;
17913         ndr_print_ptr(ndr, "environment", r->environment);
17914         ndr->depth++;
17915         if (r->environment) {
17916                 ndr_print_string(ndr, "environment", r->environment);
17917         }
17918         ndr->depth--;
17919         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17920         ndr->depth++;
17921         if (r->dll_name) {
17922                 ndr_print_string(ndr, "dll_name", r->dll_name);
17923         }
17924         ndr->depth--;
17925         ndr->depth--;
17926 }
17927
17928 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17929 {
17930         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17931 }
17932
17933 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17934 {
17935         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17936         if (ndr_flags & NDR_SCALARS) {
17937                 int level = ndr_push_get_switch_value(ndr, r);
17938                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17939                 switch (level) {
17940                         case 1: {
17941                                 NDR_CHECK(ndr_push_align(ndr, 5));
17942                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17943                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17944                         break; }
17945
17946                         case 2: {
17947                                 NDR_CHECK(ndr_push_align(ndr, 5));
17948                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17949                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17950                         break; }
17951
17952                         default: {
17953                         break; }
17954
17955                 }
17956         }
17957         if (ndr_flags & NDR_BUFFERS) {
17958                 int level = ndr_push_get_switch_value(ndr, r);
17959                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17960                 switch (level) {
17961                         case 1:
17962                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17963                         break;
17964
17965                         case 2:
17966                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17967                         break;
17968
17969                         default:
17970                         break;
17971
17972                 }
17973         }
17974         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17975         return NDR_ERR_SUCCESS;
17976 }
17977
17978 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17979 {
17980         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17981         int level;
17982         level = ndr_pull_get_switch_value(ndr, r);
17983         if (ndr_flags & NDR_SCALARS) {
17984                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17985                 switch (level) {
17986                         case 1: {
17987                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17988                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17989                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17990                         break; }
17991
17992                         case 2: {
17993                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17994                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17995                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17996                         break; }
17997
17998                         default: {
17999                         break; }
18000
18001                 }
18002         }
18003         if (ndr_flags & NDR_BUFFERS) {
18004                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18005                 switch (level) {
18006                         case 1:
18007                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18008                         break;
18009
18010                         case 2:
18011                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18012                         break;
18013
18014                         default:
18015                         break;
18016
18017                 }
18018         }
18019         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18020         return NDR_ERR_SUCCESS;
18021 }
18022
18023 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18024 {
18025         int level;
18026         level = ndr_print_get_switch_value(ndr, r);
18027         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18028         switch (level) {
18029                 case 1:
18030                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18031                 break;
18032
18033                 case 2:
18034                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18035                 break;
18036
18037                 default:
18038                 break;
18039
18040         }
18041 }
18042
18043 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18044 {
18045         if (ndr_flags & NDR_SCALARS) {
18046                 NDR_CHECK(ndr_push_align(ndr, 5));
18047                 {
18048                         uint32_t _flags_save_string = ndr->flags;
18049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18051                         ndr->flags = _flags_save_string;
18052                 }
18053                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18054         }
18055         if (ndr_flags & NDR_BUFFERS) {
18056                 {
18057                         uint32_t _flags_save_string = ndr->flags;
18058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18059                         if (r->name_array) {
18060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
18061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18062                         }
18063                         ndr->flags = _flags_save_string;
18064                 }
18065         }
18066         return NDR_ERR_SUCCESS;
18067 }
18068
18069 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18070 {
18071         uint32_t _ptr_name_array;
18072         TALLOC_CTX *_mem_save_name_array_0;
18073         if (ndr_flags & NDR_SCALARS) {
18074                 NDR_CHECK(ndr_pull_align(ndr, 5));
18075                 {
18076                         uint32_t _flags_save_string = ndr->flags;
18077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18079                         if (_ptr_name_array) {
18080                                 NDR_PULL_ALLOC(ndr, r->name_array);
18081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18082                         } else {
18083                                 r->name_array = NULL;
18084                         }
18085                         ndr->flags = _flags_save_string;
18086                 }
18087                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18088         }
18089         if (ndr_flags & NDR_BUFFERS) {
18090                 {
18091                         uint32_t _flags_save_string = ndr->flags;
18092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18093                         if (r->name_array) {
18094                                 uint32_t _relative_save_offset;
18095                                 _relative_save_offset = ndr->offset;
18096                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18097                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18098                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18099                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18100                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18101                                 if (ndr->offset > ndr->relative_highest_offset) {
18102                                         ndr->relative_highest_offset = ndr->offset;
18103                                 }
18104                                 ndr->offset = _relative_save_offset;
18105                         }
18106                         ndr->flags = _flags_save_string;
18107                 }
18108         }
18109         return NDR_ERR_SUCCESS;
18110 }
18111
18112 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18113 {
18114         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18115         ndr->depth++;
18116         ndr_print_ptr(ndr, "name_array", r->name_array);
18117         ndr->depth++;
18118         if (r->name_array) {
18119                 ndr_print_string(ndr, "name_array", r->name_array);
18120         }
18121         ndr->depth--;
18122         ndr->depth--;
18123 }
18124
18125 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18126 {
18127         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18128 }
18129
18130 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18131 {
18132         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18133         if (ndr_flags & NDR_SCALARS) {
18134                 int level = ndr_push_get_switch_value(ndr, r);
18135                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18136                 switch (level) {
18137                         case 1: {
18138                                 NDR_CHECK(ndr_push_align(ndr, 5));
18139                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18140                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18141                         break; }
18142
18143                         default: {
18144                         break; }
18145
18146                 }
18147         }
18148         if (ndr_flags & NDR_BUFFERS) {
18149                 int level = ndr_push_get_switch_value(ndr, r);
18150                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18151                 switch (level) {
18152                         case 1:
18153                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18154                         break;
18155
18156                         default:
18157                         break;
18158
18159                 }
18160         }
18161         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18162         return NDR_ERR_SUCCESS;
18163 }
18164
18165 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18166 {
18167         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18168         int level;
18169         level = ndr_pull_get_switch_value(ndr, r);
18170         if (ndr_flags & NDR_SCALARS) {
18171                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18172                 switch (level) {
18173                         case 1: {
18174                                 NDR_CHECK(ndr_pull_align(ndr, 5));
18175                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18176                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18177                         break; }
18178
18179                         default: {
18180                         break; }
18181
18182                 }
18183         }
18184         if (ndr_flags & NDR_BUFFERS) {
18185                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18186                 switch (level) {
18187                         case 1:
18188                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18189                         break;
18190
18191                         default:
18192                         break;
18193
18194                 }
18195         }
18196         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18197         return NDR_ERR_SUCCESS;
18198 }
18199
18200 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18201 {
18202         int level;
18203         level = ndr_print_get_switch_value(ndr, r);
18204         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18205         switch (level) {
18206                 case 1:
18207                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18208                 break;
18209
18210                 default:
18211                 break;
18212
18213         }
18214 }
18215
18216 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18217 {
18218         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18219         return NDR_ERR_SUCCESS;
18220 }
18221
18222 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18223 {
18224         uint32_t v;
18225         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18226         *r = v;
18227         return NDR_ERR_SUCCESS;
18228 }
18229
18230 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18231 {
18232         ndr_print_uint32(ndr, name, r);
18233         ndr->depth++;
18234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18235         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18255         ndr->depth--;
18256 }
18257
18258 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18259 {
18260         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18261         return NDR_ERR_SUCCESS;
18262 }
18263
18264 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18265 {
18266         uint16_t v;
18267         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18268         *r = v;
18269         return NDR_ERR_SUCCESS;
18270 }
18271
18272 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18273 {
18274         const char *val = NULL;
18275
18276         switch (r) {
18277                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18278                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18279                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18280                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18281                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18282                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18283                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18284                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18285                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18286                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18287                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18288                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18289                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18290                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18291                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18292                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18293                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18294                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18295                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18296                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18297                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18298                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18299                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18300                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18301         }
18302         ndr_print_enum(ndr, name, "ENUM", val, r);
18303 }
18304
18305 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18306 {
18307         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18308         return NDR_ERR_SUCCESS;
18309 }
18310
18311 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18312 {
18313         uint16_t v;
18314         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18315         *r = v;
18316         return NDR_ERR_SUCCESS;
18317 }
18318
18319 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18320 {
18321         const char *val = NULL;
18322
18323         switch (r) {
18324                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18325                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18326                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18327                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18328                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18329                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18330                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18331                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18332                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18333                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18334                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18335                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18336                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18337                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18338                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18339                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18340                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18341                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18342                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18343                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18344                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18345                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18346                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18347                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18348                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18349                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18350                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18351                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18352         }
18353         ndr_print_enum(ndr, name, "ENUM", val, r);
18354 }
18355
18356 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18357 {
18358         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18359         return NDR_ERR_SUCCESS;
18360 }
18361
18362 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18363 {
18364         uint16_t v;
18365         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18366         *r = v;
18367         return NDR_ERR_SUCCESS;
18368 }
18369
18370 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18371 {
18372         const char *val = NULL;
18373
18374         switch (r) {
18375                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18376                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18377         }
18378         ndr_print_enum(ndr, name, "ENUM", val, r);
18379 }
18380
18381 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18382 {
18383         if (ndr_flags & NDR_SCALARS) {
18384                 int level = ndr_push_get_switch_value(ndr, r);
18385                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18386                 switch (level) {
18387                         case PRINTER_NOTIFY_TYPE: {
18388                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18389                         break; }
18390
18391                         case JOB_NOTIFY_TYPE: {
18392                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18393                         break; }
18394
18395                         default: {
18396                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18397                         break; }
18398
18399                 }
18400         }
18401         if (ndr_flags & NDR_BUFFERS) {
18402                 int level = ndr_push_get_switch_value(ndr, r);
18403                 switch (level) {
18404                         case PRINTER_NOTIFY_TYPE:
18405                         break;
18406
18407                         case JOB_NOTIFY_TYPE:
18408                         break;
18409
18410                         default:
18411                         break;
18412
18413                 }
18414         }
18415         return NDR_ERR_SUCCESS;
18416 }
18417
18418 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18419 {
18420         int level;
18421         level = ndr_pull_get_switch_value(ndr, r);
18422         if (ndr_flags & NDR_SCALARS) {
18423                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18424                 switch (level) {
18425                         case PRINTER_NOTIFY_TYPE: {
18426                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18427                         break; }
18428
18429                         case JOB_NOTIFY_TYPE: {
18430                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18431                         break; }
18432
18433                         default: {
18434                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18435                         break; }
18436
18437                 }
18438         }
18439         if (ndr_flags & NDR_BUFFERS) {
18440                 switch (level) {
18441                         case PRINTER_NOTIFY_TYPE:
18442                         break;
18443
18444                         case JOB_NOTIFY_TYPE:
18445                         break;
18446
18447                         default:
18448                         break;
18449
18450                 }
18451         }
18452         return NDR_ERR_SUCCESS;
18453 }
18454
18455 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18456 {
18457         uint32_t cntr_fields_1;
18458         if (ndr_flags & NDR_SCALARS) {
18459                 NDR_CHECK(ndr_push_align(ndr, 5));
18460                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18461                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18466                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18467         }
18468         if (ndr_flags & NDR_BUFFERS) {
18469                 if (r->fields) {
18470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18471                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18472                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18473                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18474                         }
18475                 }
18476         }
18477         return NDR_ERR_SUCCESS;
18478 }
18479
18480 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18481 {
18482         uint32_t _ptr_fields;
18483         uint32_t cntr_fields_1;
18484         TALLOC_CTX *_mem_save_fields_0;
18485         TALLOC_CTX *_mem_save_fields_1;
18486         if (ndr_flags & NDR_SCALARS) {
18487                 NDR_CHECK(ndr_pull_align(ndr, 5));
18488                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18489                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18494                 if (_ptr_fields) {
18495                         NDR_PULL_ALLOC(ndr, r->fields);
18496                 } else {
18497                         r->fields = NULL;
18498                 }
18499                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18500         }
18501         if (ndr_flags & NDR_BUFFERS) {
18502                 if (r->fields) {
18503                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18504                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18506                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18507                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18508                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18509                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18510                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18511                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18512                         }
18513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18514                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18515                 }
18516                 if (r->fields) {
18517                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18518                 }
18519         }
18520         return NDR_ERR_SUCCESS;
18521 }
18522
18523 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18524 {
18525         uint32_t cntr_fields_1;
18526         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18527         ndr->depth++;
18528         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18529         ndr_print_uint16(ndr, "u1", r->u1);
18530         ndr_print_uint32(ndr, "u2", r->u2);
18531         ndr_print_uint32(ndr, "u3", r->u3);
18532         ndr_print_uint32(ndr, "count", r->count);
18533         ndr_print_ptr(ndr, "fields", r->fields);
18534         ndr->depth++;
18535         if (r->fields) {
18536                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18537                 ndr->depth++;
18538                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18539                         char *idx_1=NULL;
18540                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18541                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18542                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18543                                 free(idx_1);
18544                         }
18545                 }
18546                 ndr->depth--;
18547         }
18548         ndr->depth--;
18549         ndr->depth--;
18550 }
18551
18552 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18553 {
18554         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18555         return NDR_ERR_SUCCESS;
18556 }
18557
18558 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18559 {
18560         uint32_t v;
18561         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18562         *r = v;
18563         return NDR_ERR_SUCCESS;
18564 }
18565
18566 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18567 {
18568         ndr_print_uint32(ndr, name, r);
18569         ndr->depth++;
18570         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18571         ndr->depth--;
18572 }
18573
18574 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18575 {
18576         uint32_t cntr_types_1;
18577         if (ndr_flags & NDR_SCALARS) {
18578                 NDR_CHECK(ndr_push_align(ndr, 5));
18579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18580                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18583                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18584         }
18585         if (ndr_flags & NDR_BUFFERS) {
18586                 if (r->types) {
18587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18588                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18589                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18590                         }
18591                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18592                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18593                         }
18594                 }
18595         }
18596         return NDR_ERR_SUCCESS;
18597 }
18598
18599 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18600 {
18601         uint32_t _ptr_types;
18602         uint32_t cntr_types_1;
18603         TALLOC_CTX *_mem_save_types_0;
18604         TALLOC_CTX *_mem_save_types_1;
18605         if (ndr_flags & NDR_SCALARS) {
18606                 NDR_CHECK(ndr_pull_align(ndr, 5));
18607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18608                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18611                 if (_ptr_types) {
18612                         NDR_PULL_ALLOC(ndr, r->types);
18613                 } else {
18614                         r->types = NULL;
18615                 }
18616                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18617         }
18618         if (ndr_flags & NDR_BUFFERS) {
18619                 if (r->types) {
18620                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18621                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18622                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18623                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18624                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18625                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18626                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18627                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18628                         }
18629                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18630                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18631                         }
18632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18634                 }
18635                 if (r->types) {
18636                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18637                 }
18638         }
18639         return NDR_ERR_SUCCESS;
18640 }
18641
18642 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18643 {
18644         uint32_t cntr_types_1;
18645         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18646         ndr->depth++;
18647         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18648         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18649         ndr_print_uint32(ndr, "count", r->count);
18650         ndr_print_ptr(ndr, "types", r->types);
18651         ndr->depth++;
18652         if (r->types) {
18653                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18654                 ndr->depth++;
18655                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18656                         char *idx_1=NULL;
18657                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18658                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18659                                 free(idx_1);
18660                         }
18661                 }
18662                 ndr->depth--;
18663         }
18664         ndr->depth--;
18665         ndr->depth--;
18666 }
18667
18668 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18669 {
18670         if (ndr_flags & NDR_SCALARS) {
18671                 NDR_CHECK(ndr_push_align(ndr, 5));
18672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18674                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18675         }
18676         if (ndr_flags & NDR_BUFFERS) {
18677                 if (r->string) {
18678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18679                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18680                 }
18681         }
18682         return NDR_ERR_SUCCESS;
18683 }
18684
18685 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18686 {
18687         uint32_t _ptr_string;
18688         TALLOC_CTX *_mem_save_string_0;
18689         if (ndr_flags & NDR_SCALARS) {
18690                 NDR_CHECK(ndr_pull_align(ndr, 5));
18691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18692                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18693                 if (_ptr_string) {
18694                         NDR_PULL_ALLOC(ndr, r->string);
18695                 } else {
18696                         r->string = NULL;
18697                 }
18698                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18699         }
18700         if (ndr_flags & NDR_BUFFERS) {
18701                 if (r->string) {
18702                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18703                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18705                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18707                 }
18708                 if (r->string) {
18709                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18710                 }
18711         }
18712         return NDR_ERR_SUCCESS;
18713 }
18714
18715 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18716 {
18717         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18718         ndr->depth++;
18719         ndr_print_uint32(ndr, "size", r->size);
18720         ndr_print_ptr(ndr, "string", r->string);
18721         ndr->depth++;
18722         if (r->string) {
18723                 ndr_print_string(ndr, "string", r->string);
18724         }
18725         ndr->depth--;
18726         ndr->depth--;
18727 }
18728
18729 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18730 {
18731         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18732         return NDR_ERR_SUCCESS;
18733 }
18734
18735 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18736 {
18737         uint32_t v;
18738         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18739         *r = v;
18740         return NDR_ERR_SUCCESS;
18741 }
18742
18743 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18744 {
18745         const char *val = NULL;
18746
18747         switch (r) {
18748                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18749                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18750                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18751                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18752                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18753         }
18754         ndr_print_enum(ndr, name, "ENUM", val, r);
18755 }
18756
18757 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18758 {
18759         if (ndr_flags & NDR_SCALARS) {
18760                 int level = ndr_push_get_switch_value(ndr, r);
18761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18762                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18763                 switch (level) {
18764                         case 1: {
18765                                 uint32_t cntr_integer_0;
18766                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18767                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18768                                 }
18769                         break; }
18770
18771                         case 2: {
18772                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18773                         break; }
18774
18775                         case 3: {
18776                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18777                         break; }
18778
18779                         case 4: {
18780                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18781                         break; }
18782
18783                         case 5: {
18784                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18785                         break; }
18786
18787                         default:
18788                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18789                 }
18790         }
18791         if (ndr_flags & NDR_BUFFERS) {
18792                 int level = ndr_push_get_switch_value(ndr, r);
18793                 switch (level) {
18794                         case 1:
18795                         break;
18796
18797                         case 2:
18798                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18799                         break;
18800
18801                         case 3:
18802                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18803                         break;
18804
18805                         case 4:
18806                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18807                         break;
18808
18809                         case 5:
18810                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18811                         break;
18812
18813                         default:
18814                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18815                 }
18816         }
18817         return NDR_ERR_SUCCESS;
18818 }
18819
18820 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18821 {
18822         int level;
18823         uint32_t _level;
18824         level = ndr_pull_get_switch_value(ndr, r);
18825         if (ndr_flags & NDR_SCALARS) {
18826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18827                 if (_level != level) {
18828                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18829                 }
18830                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18831                 switch (level) {
18832                         case 1: {
18833                                 uint32_t cntr_integer_0;
18834                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18835                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18836                                 }
18837                         break; }
18838
18839                         case 2: {
18840                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18841                         break; }
18842
18843                         case 3: {
18844                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18845                         break; }
18846
18847                         case 4: {
18848                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18849                         break; }
18850
18851                         case 5: {
18852                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18853                         break; }
18854
18855                         default:
18856                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18857                 }
18858         }
18859         if (ndr_flags & NDR_BUFFERS) {
18860                 switch (level) {
18861                         case 1:
18862                         break;
18863
18864                         case 2:
18865                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18866                         break;
18867
18868                         case 3:
18869                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18870                         break;
18871
18872                         case 4:
18873                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18874                         break;
18875
18876                         case 5:
18877                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18878                         break;
18879
18880                         default:
18881                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18882                 }
18883         }
18884         return NDR_ERR_SUCCESS;
18885 }
18886
18887 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18888 {
18889         int level;
18890         uint32_t cntr_integer_0;
18891         level = ndr_print_get_switch_value(ndr, r);
18892         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18893         switch (level) {
18894                 case 1:
18895                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18896                         ndr->depth++;
18897                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18898                                 char *idx_0=NULL;
18899                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18900                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18901                                         free(idx_0);
18902                                 }
18903                         }
18904                         ndr->depth--;
18905                 break;
18906
18907                 case 2:
18908                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18909                 break;
18910
18911                 case 3:
18912                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18913                 break;
18914
18915                 case 4:
18916                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18917                 break;
18918
18919                 case 5:
18920                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18921                 break;
18922
18923                 default:
18924                         ndr_print_bad_level(ndr, name, level);
18925         }
18926 }
18927
18928 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18929 {
18930         if (ndr_flags & NDR_SCALARS) {
18931                 NDR_CHECK(ndr_push_align(ndr, 5));
18932                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18933                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18934                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18935                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18937                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18938                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18939                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18940         }
18941         if (ndr_flags & NDR_BUFFERS) {
18942                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18943         }
18944         return NDR_ERR_SUCCESS;
18945 }
18946
18947 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18948 {
18949         if (ndr_flags & NDR_SCALARS) {
18950                 NDR_CHECK(ndr_pull_align(ndr, 5));
18951                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18952                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18953                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18954                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18956                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18957                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18958                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18959         }
18960         if (ndr_flags & NDR_BUFFERS) {
18961                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18962         }
18963         return NDR_ERR_SUCCESS;
18964 }
18965
18966 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18967 {
18968         ndr_print_struct(ndr, name, "spoolss_Notify");
18969         ndr->depth++;
18970         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18971         ndr_print_set_switch_value(ndr, &r->field, r->type);
18972         ndr_print_spoolss_Field(ndr, "field", &r->field);
18973         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18974         ndr_print_uint32(ndr, "job_id", r->job_id);
18975         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18976         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18977         ndr->depth--;
18978 }
18979
18980 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18981 {
18982         uint32_t cntr_notifies_0;
18983         if (ndr_flags & NDR_SCALARS) {
18984                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18985                 NDR_CHECK(ndr_push_align(ndr, 5));
18986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18989                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18990                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18991                 }
18992                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18993         }
18994         if (ndr_flags & NDR_BUFFERS) {
18995                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18996                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18997                 }
18998         }
18999         return NDR_ERR_SUCCESS;
19000 }
19001
19002 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19003 {
19004         uint32_t cntr_notifies_0;
19005         TALLOC_CTX *_mem_save_notifies_0;
19006         if (ndr_flags & NDR_SCALARS) {
19007                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19008                 NDR_CHECK(ndr_pull_align(ndr, 5));
19009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19012                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19013                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19014                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19015                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19016                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19017                 }
19018                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19019                 if (r->notifies) {
19020                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19021                 }
19022                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19023         }
19024         if (ndr_flags & NDR_BUFFERS) {
19025                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19026                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19027                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19028                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19029                 }
19030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19031         }
19032         return NDR_ERR_SUCCESS;
19033 }
19034
19035 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19036 {
19037         uint32_t cntr_notifies_0;
19038         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19039         ndr->depth++;
19040         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19041         ndr_print_uint32(ndr, "flags", r->flags);
19042         ndr_print_uint32(ndr, "count", r->count);
19043         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19044         ndr->depth++;
19045         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19046                 char *idx_0=NULL;
19047                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19048                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19049                         free(idx_0);
19050                 }
19051         }
19052         ndr->depth--;
19053         ndr->depth--;
19054 }
19055
19056 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19057 {
19058         if (ndr_flags & NDR_SCALARS) {
19059                 int level = ndr_push_get_switch_value(ndr, r);
19060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19061                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19062                 switch (level) {
19063                         case 0: {
19064                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19065                         break; }
19066
19067                         default:
19068                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19069                 }
19070         }
19071         if (ndr_flags & NDR_BUFFERS) {
19072                 int level = ndr_push_get_switch_value(ndr, r);
19073                 switch (level) {
19074                         case 0:
19075                                 if (r->info0) {
19076                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19077                                 }
19078                         break;
19079
19080                         default:
19081                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19082                 }
19083         }
19084         return NDR_ERR_SUCCESS;
19085 }
19086
19087 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19088 {
19089         int level;
19090         uint32_t _level;
19091         TALLOC_CTX *_mem_save_info0_0;
19092         level = ndr_pull_get_switch_value(ndr, r);
19093         if (ndr_flags & NDR_SCALARS) {
19094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19095                 if (_level != level) {
19096                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19097                 }
19098                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19099                 switch (level) {
19100                         case 0: {
19101                                 uint32_t _ptr_info0;
19102                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19103                                 if (_ptr_info0) {
19104                                         NDR_PULL_ALLOC(ndr, r->info0);
19105                                 } else {
19106                                         r->info0 = NULL;
19107                                 }
19108                         break; }
19109
19110                         default:
19111                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19112                 }
19113         }
19114         if (ndr_flags & NDR_BUFFERS) {
19115                 switch (level) {
19116                         case 0:
19117                                 if (r->info0) {
19118                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19119                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19120                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19121                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19122                                 }
19123                         break;
19124
19125                         default:
19126                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19127                 }
19128         }
19129         return NDR_ERR_SUCCESS;
19130 }
19131
19132 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19133 {
19134         int level;
19135         level = ndr_print_get_switch_value(ndr, r);
19136         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19137         switch (level) {
19138                 case 0:
19139                         ndr_print_ptr(ndr, "info0", r->info0);
19140                         ndr->depth++;
19141                         if (r->info0) {
19142                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19143                         }
19144                         ndr->depth--;
19145                 break;
19146
19147                 default:
19148                         ndr_print_bad_level(ndr, name, level);
19149         }
19150 }
19151
19152 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19153 {
19154         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19155         return NDR_ERR_SUCCESS;
19156 }
19157
19158 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19159 {
19160         uint32_t v;
19161         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19162         *r = v;
19163         return NDR_ERR_SUCCESS;
19164 }
19165
19166 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19167 {
19168         ndr_print_uint32(ndr, name, r);
19169         ndr->depth++;
19170         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19171         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19172         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19173         ndr->depth--;
19174 }
19175
19176 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19177 {
19178         if (ndr_flags & NDR_SCALARS) {
19179                 NDR_CHECK(ndr_push_align(ndr, 5));
19180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19184                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19185                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19186                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19187                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19188         }
19189         if (ndr_flags & NDR_BUFFERS) {
19190                 if (r->client) {
19191                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19194                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19195                 }
19196                 if (r->user) {
19197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19200                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19201                 }
19202         }
19203         return NDR_ERR_SUCCESS;
19204 }
19205
19206 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19207 {
19208         uint32_t _ptr_client;
19209         TALLOC_CTX *_mem_save_client_0;
19210         uint32_t _ptr_user;
19211         TALLOC_CTX *_mem_save_user_0;
19212         if (ndr_flags & NDR_SCALARS) {
19213                 NDR_CHECK(ndr_pull_align(ndr, 5));
19214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19216                 if (_ptr_client) {
19217                         NDR_PULL_ALLOC(ndr, r->client);
19218                 } else {
19219                         r->client = NULL;
19220                 }
19221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19222                 if (_ptr_user) {
19223                         NDR_PULL_ALLOC(ndr, r->user);
19224                 } else {
19225                         r->user = NULL;
19226                 }
19227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19228                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19229                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19230                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19231                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19232         }
19233         if (ndr_flags & NDR_BUFFERS) {
19234                 if (r->client) {
19235                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19236                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19237                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19238                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19239                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19240                                 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));
19241                         }
19242                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19243                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19245                 }
19246                 if (r->user) {
19247                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19248                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19249                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19250                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19251                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19252                                 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));
19253                         }
19254                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19255                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19257                 }
19258         }
19259         return NDR_ERR_SUCCESS;
19260 }
19261
19262 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19263 {
19264         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19265         ndr->depth++;
19266         ndr_print_uint32(ndr, "size", r->size);
19267         ndr_print_ptr(ndr, "client", r->client);
19268         ndr->depth++;
19269         if (r->client) {
19270                 ndr_print_string(ndr, "client", r->client);
19271         }
19272         ndr->depth--;
19273         ndr_print_ptr(ndr, "user", r->user);
19274         ndr->depth++;
19275         if (r->user) {
19276                 ndr_print_string(ndr, "user", r->user);
19277         }
19278         ndr->depth--;
19279         ndr_print_uint32(ndr, "build", r->build);
19280         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19281         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19282         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19283         ndr->depth--;
19284 }
19285
19286 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19287 {
19288         if (ndr_flags & NDR_SCALARS) {
19289                 NDR_CHECK(ndr_push_align(ndr, 4));
19290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19291                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19292         }
19293         if (ndr_flags & NDR_BUFFERS) {
19294         }
19295         return NDR_ERR_SUCCESS;
19296 }
19297
19298 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19299 {
19300         if (ndr_flags & NDR_SCALARS) {
19301                 NDR_CHECK(ndr_pull_align(ndr, 4));
19302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19303                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19304         }
19305         if (ndr_flags & NDR_BUFFERS) {
19306         }
19307         return NDR_ERR_SUCCESS;
19308 }
19309
19310 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19311 {
19312         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19313         ndr->depth++;
19314         ndr_print_uint32(ndr, "not_used", r->not_used);
19315         ndr->depth--;
19316 }
19317
19318 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19319 {
19320         if (ndr_flags & NDR_SCALARS) {
19321                 NDR_CHECK(ndr_push_align(ndr, 5));
19322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19328                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19329                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19330                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19331                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19332                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19333         }
19334         if (ndr_flags & NDR_BUFFERS) {
19335                 if (r->client) {
19336                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19337                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19339                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19340                 }
19341                 if (r->user) {
19342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19343                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19346                 }
19347         }
19348         return NDR_ERR_SUCCESS;
19349 }
19350
19351 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19352 {
19353         uint32_t _ptr_client;
19354         TALLOC_CTX *_mem_save_client_0;
19355         uint32_t _ptr_user;
19356         TALLOC_CTX *_mem_save_user_0;
19357         if (ndr_flags & NDR_SCALARS) {
19358                 NDR_CHECK(ndr_pull_align(ndr, 5));
19359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19363                 if (_ptr_client) {
19364                         NDR_PULL_ALLOC(ndr, r->client);
19365                 } else {
19366                         r->client = NULL;
19367                 }
19368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19369                 if (_ptr_user) {
19370                         NDR_PULL_ALLOC(ndr, r->user);
19371                 } else {
19372                         r->user = NULL;
19373                 }
19374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19375                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19376                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19377                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19378                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19379                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19380         }
19381         if (ndr_flags & NDR_BUFFERS) {
19382                 if (r->client) {
19383                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19384                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19385                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19386                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19387                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19388                                 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));
19389                         }
19390                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19391                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19393                 }
19394                 if (r->user) {
19395                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19396                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19399                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19400                                 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));
19401                         }
19402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19403                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19405                 }
19406         }
19407         return NDR_ERR_SUCCESS;
19408 }
19409
19410 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19411 {
19412         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19413         ndr->depth++;
19414         ndr_print_uint32(ndr, "size", r->size);
19415         ndr_print_uint32(ndr, "flags", r->flags);
19416         ndr_print_uint32(ndr, "size2", r->size2);
19417         ndr_print_ptr(ndr, "client", r->client);
19418         ndr->depth++;
19419         if (r->client) {
19420                 ndr_print_string(ndr, "client", r->client);
19421         }
19422         ndr->depth--;
19423         ndr_print_ptr(ndr, "user", r->user);
19424         ndr->depth++;
19425         if (r->user) {
19426                 ndr_print_string(ndr, "user", r->user);
19427         }
19428         ndr->depth--;
19429         ndr_print_uint32(ndr, "build", r->build);
19430         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19431         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19432         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19433         ndr_print_udlong(ndr, "reserved", r->reserved);
19434         ndr->depth--;
19435 }
19436
19437 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19438 {
19439         if (ndr_flags & NDR_SCALARS) {
19440                 int level = ndr_push_get_switch_value(ndr, r);
19441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19442                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19443                 switch (level) {
19444                         case 1: {
19445                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19446                         break; }
19447
19448                         case 2: {
19449                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19450                         break; }
19451
19452                         case 3: {
19453                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19454                         break; }
19455
19456                         default:
19457                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19458                 }
19459         }
19460         if (ndr_flags & NDR_BUFFERS) {
19461                 int level = ndr_push_get_switch_value(ndr, r);
19462                 switch (level) {
19463                         case 1:
19464                                 if (r->level1) {
19465                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19466                                 }
19467                         break;
19468
19469                         case 2:
19470                                 if (r->level2) {
19471                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19472                                 }
19473                         break;
19474
19475                         case 3:
19476                                 if (r->level3) {
19477                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19478                                 }
19479                         break;
19480
19481                         default:
19482                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19483                 }
19484         }
19485         return NDR_ERR_SUCCESS;
19486 }
19487
19488 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19489 {
19490         int level;
19491         uint32_t _level;
19492         TALLOC_CTX *_mem_save_level1_0;
19493         TALLOC_CTX *_mem_save_level2_0;
19494         TALLOC_CTX *_mem_save_level3_0;
19495         level = ndr_pull_get_switch_value(ndr, r);
19496         if (ndr_flags & NDR_SCALARS) {
19497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19498                 if (_level != level) {
19499                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19500                 }
19501                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19502                 switch (level) {
19503                         case 1: {
19504                                 uint32_t _ptr_level1;
19505                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19506                                 if (_ptr_level1) {
19507                                         NDR_PULL_ALLOC(ndr, r->level1);
19508                                 } else {
19509                                         r->level1 = NULL;
19510                                 }
19511                         break; }
19512
19513                         case 2: {
19514                                 uint32_t _ptr_level2;
19515                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19516                                 if (_ptr_level2) {
19517                                         NDR_PULL_ALLOC(ndr, r->level2);
19518                                 } else {
19519                                         r->level2 = NULL;
19520                                 }
19521                         break; }
19522
19523                         case 3: {
19524                                 uint32_t _ptr_level3;
19525                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19526                                 if (_ptr_level3) {
19527                                         NDR_PULL_ALLOC(ndr, r->level3);
19528                                 } else {
19529                                         r->level3 = NULL;
19530                                 }
19531                         break; }
19532
19533                         default:
19534                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19535                 }
19536         }
19537         if (ndr_flags & NDR_BUFFERS) {
19538                 switch (level) {
19539                         case 1:
19540                                 if (r->level1) {
19541                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19542                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19543                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19544                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19545                                 }
19546                         break;
19547
19548                         case 2:
19549                                 if (r->level2) {
19550                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19551                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19552                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19553                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19554                                 }
19555                         break;
19556
19557                         case 3:
19558                                 if (r->level3) {
19559                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19560                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19561                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19562                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19563                                 }
19564                         break;
19565
19566                         default:
19567                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19568                 }
19569         }
19570         return NDR_ERR_SUCCESS;
19571 }
19572
19573 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19574 {
19575         int level;
19576         level = ndr_print_get_switch_value(ndr, r);
19577         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19578         switch (level) {
19579                 case 1:
19580                         ndr_print_ptr(ndr, "level1", r->level1);
19581                         ndr->depth++;
19582                         if (r->level1) {
19583                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19584                         }
19585                         ndr->depth--;
19586                 break;
19587
19588                 case 2:
19589                         ndr_print_ptr(ndr, "level2", r->level2);
19590                         ndr->depth++;
19591                         if (r->level2) {
19592                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19593                         }
19594                         ndr->depth--;
19595                 break;
19596
19597                 case 3:
19598                         ndr_print_ptr(ndr, "level3", r->level3);
19599                         ndr->depth++;
19600                         if (r->level3) {
19601                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19602                         }
19603                         ndr->depth--;
19604                 break;
19605
19606                 default:
19607                         ndr_print_bad_level(ndr, name, level);
19608         }
19609 }
19610
19611 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19612 {
19613         if (ndr_flags & NDR_SCALARS) {
19614                 NDR_CHECK(ndr_push_align(ndr, 5));
19615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19616                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19617                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19619         }
19620         if (ndr_flags & NDR_BUFFERS) {
19621                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19622         }
19623         return NDR_ERR_SUCCESS;
19624 }
19625
19626 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19627 {
19628         if (ndr_flags & NDR_SCALARS) {
19629                 NDR_CHECK(ndr_pull_align(ndr, 5));
19630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19631                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19632                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19633                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19634         }
19635         if (ndr_flags & NDR_BUFFERS) {
19636                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19637         }
19638         return NDR_ERR_SUCCESS;
19639 }
19640
19641 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19642 {
19643         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19644         ndr->depth++;
19645         ndr_print_uint32(ndr, "level", r->level);
19646         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19647         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19648         ndr->depth--;
19649 }
19650
19651 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19652 {
19653         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19654         return NDR_ERR_SUCCESS;
19655 }
19656
19657 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19658 {
19659         uint32_t v;
19660         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19661         *r = v;
19662         return NDR_ERR_SUCCESS;
19663 }
19664
19665 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19666 {
19667         ndr_print_uint32(ndr, name, r);
19668         ndr->depth++;
19669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19675         ndr->depth--;
19676 }
19677
19678 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19679 {
19680         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19681         if (ndr_flags & NDR_SCALARS) {
19682                 NDR_CHECK(ndr_push_align(ndr, 5));
19683                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19684                 {
19685                         uint32_t _flags_save_string = ndr->flags;
19686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19687                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19688                         ndr->flags = _flags_save_string;
19689                 }
19690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19691                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19692                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19694                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19695         }
19696         if (ndr_flags & NDR_BUFFERS) {
19697                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19698                 {
19699                         uint32_t _flags_save_string = ndr->flags;
19700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19701                         if (r->value_name) {
19702                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19703                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19704                         }
19705                         ndr->flags = _flags_save_string;
19706                 }
19707                 if (r->data) {
19708                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19709                         {
19710                                 struct ndr_push *_ndr_data;
19711                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19712                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19713                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19714                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19715                         }
19716                 }
19717         }
19718         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19719         return NDR_ERR_SUCCESS;
19720 }
19721
19722 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19723 {
19724         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19725         uint32_t _ptr_value_name;
19726         TALLOC_CTX *_mem_save_value_name_0;
19727         uint32_t _ptr_data;
19728         TALLOC_CTX *_mem_save_data_0;
19729         if (ndr_flags & NDR_SCALARS) {
19730                 NDR_CHECK(ndr_pull_align(ndr, 5));
19731                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19732                 {
19733                         uint32_t _flags_save_string = ndr->flags;
19734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19736                         if (_ptr_value_name) {
19737                                 NDR_PULL_ALLOC(ndr, r->value_name);
19738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19739                         } else {
19740                                 r->value_name = NULL;
19741                         }
19742                         ndr->flags = _flags_save_string;
19743                 }
19744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19745                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19747                 if (_ptr_data) {
19748                         NDR_PULL_ALLOC(ndr, r->data);
19749                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19750                 } else {
19751                         r->data = NULL;
19752                 }
19753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19754                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19755         }
19756         if (ndr_flags & NDR_BUFFERS) {
19757                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19758                 {
19759                         uint32_t _flags_save_string = ndr->flags;
19760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19761                         if (r->value_name) {
19762                                 uint32_t _relative_save_offset;
19763                                 _relative_save_offset = ndr->offset;
19764                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19765                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19766                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19767                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19768                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19769                                 if (ndr->offset > ndr->relative_highest_offset) {
19770                                         ndr->relative_highest_offset = ndr->offset;
19771                                 }
19772                                 ndr->offset = _relative_save_offset;
19773                         }
19774                         ndr->flags = _flags_save_string;
19775                 }
19776                 if (r->data) {
19777                         uint32_t _relative_save_offset;
19778                         _relative_save_offset = ndr->offset;
19779                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19780                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19781                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19782                         {
19783                                 struct ndr_pull *_ndr_data;
19784                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19785                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19786                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19787                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19788                         }
19789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19790                         if (ndr->offset > ndr->relative_highest_offset) {
19791                                 ndr->relative_highest_offset = ndr->offset;
19792                         }
19793                         ndr->offset = _relative_save_offset;
19794                 }
19795         }
19796         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19797         return NDR_ERR_SUCCESS;
19798 }
19799
19800 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19801 {
19802         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19803         ndr->depth++;
19804         ndr_print_ptr(ndr, "value_name", r->value_name);
19805         ndr->depth++;
19806         if (r->value_name) {
19807                 ndr_print_string(ndr, "value_name", r->value_name);
19808         }
19809         ndr->depth--;
19810         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19811         ndr_print_winreg_Type(ndr, "type", r->type);
19812         ndr_print_ptr(ndr, "data", r->data);
19813         ndr->depth++;
19814         if (r->data) {
19815                 ndr_print_set_switch_value(ndr, r->data, r->type);
19816                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19817         }
19818         ndr->depth--;
19819         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags):r->data_length);
19820         ndr->depth--;
19821 }
19822
19823 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19824 {
19825         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19826 }
19827
19828 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19829 {
19830         if (ndr_flags & NDR_SCALARS) {
19831                 int level = ndr_push_get_switch_value(ndr, r);
19832                 NDR_CHECK(ndr_push_union_align(ndr, 4));
19833                 switch (level) {
19834                         case 0: {
19835                         break; }
19836
19837                         case 1: {
19838                         break; }
19839
19840                         default: {
19841                                 {
19842                                         uint32_t _flags_save_string_array = ndr->flags;
19843                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19844                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19845                                         ndr->flags = _flags_save_string_array;
19846                                 }
19847                         break; }
19848
19849                 }
19850         }
19851         if (ndr_flags & NDR_BUFFERS) {
19852                 int level = ndr_push_get_switch_value(ndr, r);
19853                 switch (level) {
19854                         case 0:
19855                         break;
19856
19857                         case 1:
19858                         break;
19859
19860                         default:
19861                         break;
19862
19863                 }
19864         }
19865         return NDR_ERR_SUCCESS;
19866 }
19867
19868 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19869 {
19870         int level;
19871         level = ndr_pull_get_switch_value(ndr, r);
19872         if (ndr_flags & NDR_SCALARS) {
19873                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
19874                 switch (level) {
19875                         case 0: {
19876                         break; }
19877
19878                         case 1: {
19879                         break; }
19880
19881                         default: {
19882                                 {
19883                                         uint32_t _flags_save_string_array = ndr->flags;
19884                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19885                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19886                                         ndr->flags = _flags_save_string_array;
19887                                 }
19888                         break; }
19889
19890                 }
19891         }
19892         if (ndr_flags & NDR_BUFFERS) {
19893                 switch (level) {
19894                         case 0:
19895                         break;
19896
19897                         case 1:
19898                         break;
19899
19900                         default:
19901                         break;
19902
19903                 }
19904         }
19905         return NDR_ERR_SUCCESS;
19906 }
19907
19908 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19909 {
19910         int level;
19911         level = ndr_print_get_switch_value(ndr, r);
19912         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19913         switch (level) {
19914                 case 0:
19915                 break;
19916
19917                 case 1:
19918                 break;
19919
19920                 default:
19921                         ndr_print_string_array(ndr, "string_array", r->string_array);
19922                 break;
19923
19924         }
19925 }
19926
19927 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19928 {
19929         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19930         return NDR_ERR_SUCCESS;
19931 }
19932
19933 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19934 {
19935         uint32_t v;
19936         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19937         *r = v;
19938         return NDR_ERR_SUCCESS;
19939 }
19940
19941 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19942 {
19943         ndr_print_uint32(ndr, name, r);
19944         ndr->depth++;
19945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19948         ndr->depth--;
19949 }
19950
19951 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19952 {
19953         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19954         return NDR_ERR_SUCCESS;
19955 }
19956
19957 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19958 {
19959         uint32_t v;
19960         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19961         *r = v;
19962         return NDR_ERR_SUCCESS;
19963 }
19964
19965 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19966 {
19967         const char *val = NULL;
19968
19969         switch (r) {
19970                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19971                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19972         }
19973         ndr_print_enum(ndr, name, "ENUM", val, r);
19974 }
19975
19976 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19977 {
19978         if (ndr_flags & NDR_SCALARS) {
19979                 NDR_CHECK(ndr_push_align(ndr, 4));
19980                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19982                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19985                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19986                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19988                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19989                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19990                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19991                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19995                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19996         }
19997         if (ndr_flags & NDR_BUFFERS) {
19998         }
19999         return NDR_ERR_SUCCESS;
20000 }
20001
20002 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20003 {
20004         if (ndr_flags & NDR_SCALARS) {
20005                 NDR_CHECK(ndr_pull_align(ndr, 4));
20006                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20008                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20011                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20012                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20014                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20015                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20016                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20017                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20021                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20022         }
20023         if (ndr_flags & NDR_BUFFERS) {
20024         }
20025         return NDR_ERR_SUCCESS;
20026 }
20027
20028 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20029 {
20030         ndr_print_struct(ndr, name, "spoolss_PortData1");
20031         ndr->depth++;
20032         ndr_print_string(ndr, "portname", r->portname);
20033         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20034         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20035         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20036         ndr_print_uint32(ndr, "reserved", r->reserved);
20037         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20038         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20039         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20040         ndr_print_string(ndr, "queue", r->queue);
20041         ndr_print_string(ndr, "ip_address", r->ip_address);
20042         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20043         ndr_print_string(ndr, "device_type", r->device_type);
20044         ndr_print_uint32(ndr, "port_number", r->port_number);
20045         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20046         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20047         ndr->depth--;
20048 }
20049
20050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20051 {
20052         if (ndr_flags & NDR_SCALARS) {
20053                 NDR_CHECK(ndr_push_align(ndr, 4));
20054                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20056                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20059                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20060                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20062                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20063                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20068                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20069         }
20070         if (ndr_flags & NDR_BUFFERS) {
20071         }
20072         return NDR_ERR_SUCCESS;
20073 }
20074
20075 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20076 {
20077         if (ndr_flags & NDR_SCALARS) {
20078                 NDR_CHECK(ndr_pull_align(ndr, 4));
20079                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20081                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20084                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20085                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20087                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20088                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20093                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20094         }
20095         if (ndr_flags & NDR_BUFFERS) {
20096         }
20097         return NDR_ERR_SUCCESS;
20098 }
20099
20100 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20101 {
20102         ndr_print_struct(ndr, name, "spoolss_PortData2");
20103         ndr->depth++;
20104         ndr_print_string(ndr, "portname", r->portname);
20105         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20106         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20107         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20108         ndr_print_uint32(ndr, "reserved", r->reserved);
20109         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20110         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20111         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20112         ndr_print_string(ndr, "queue", r->queue);
20113         ndr_print_string(ndr, "device_type", r->device_type);
20114         ndr_print_uint32(ndr, "port_number", r->port_number);
20115         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20116         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20117         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20118         ndr->depth--;
20119 }
20120
20121 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20122 {
20123         if (ndr_flags & NDR_SCALARS) {
20124                 NDR_CHECK(ndr_push_align(ndr, 4));
20125                 {
20126                         uint32_t _flags_save_string = ndr->flags;
20127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20128                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20129                         ndr->flags = _flags_save_string;
20130                 }
20131                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20132         }
20133         if (ndr_flags & NDR_BUFFERS) {
20134         }
20135         return NDR_ERR_SUCCESS;
20136 }
20137
20138 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20139 {
20140         if (ndr_flags & NDR_SCALARS) {
20141                 NDR_CHECK(ndr_pull_align(ndr, 4));
20142                 {
20143                         uint32_t _flags_save_string = ndr->flags;
20144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20145                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20146                         ndr->flags = _flags_save_string;
20147                 }
20148                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20149         }
20150         if (ndr_flags & NDR_BUFFERS) {
20151         }
20152         return NDR_ERR_SUCCESS;
20153 }
20154
20155 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20156 {
20157         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20158         ndr->depth++;
20159         ndr_print_string(ndr, "dll_name", r->dll_name);
20160         ndr->depth--;
20161 }
20162
20163 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20164 {
20165         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20166         return NDR_ERR_SUCCESS;
20167 }
20168
20169 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20170 {
20171         uint32_t v;
20172         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20173         *r = v;
20174         return NDR_ERR_SUCCESS;
20175 }
20176
20177 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20178 {
20179         ndr_print_uint32(ndr, name, r);
20180         ndr->depth++;
20181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20189         ndr->depth--;
20190 }
20191
20192 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20193 {
20194         if (ndr_flags & NDR_SCALARS) {
20195                 NDR_CHECK(ndr_push_align(ndr, 8));
20196                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20197                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20198                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20199                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20200                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20201         }
20202         if (ndr_flags & NDR_BUFFERS) {
20203         }
20204         return NDR_ERR_SUCCESS;
20205 }
20206
20207 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20208 {
20209         if (ndr_flags & NDR_SCALARS) {
20210                 NDR_CHECK(ndr_pull_align(ndr, 8));
20211                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20212                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20213                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20214                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20215                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20216         }
20217         if (ndr_flags & NDR_BUFFERS) {
20218         }
20219         return NDR_ERR_SUCCESS;
20220 }
20221
20222 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20223 {
20224         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20225         ndr->depth++;
20226         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20227         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20228         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20229         ndr_print_string(ndr, "formname", r->formname);
20230         ndr->depth--;
20231 }
20232
20233 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20234 {
20235         if (flags & NDR_IN) {
20236                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20238                 if (r->in.server) {
20239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20242                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20243                 }
20244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20246                 if (r->in.buffer) {
20247                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20248                 }
20249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20250         }
20251         if (flags & NDR_OUT) {
20252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20253                 if (r->out.info) {
20254                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20255                 }
20256                 if (r->out.needed == NULL) {
20257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20258                 }
20259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20260                 if (r->out.count == NULL) {
20261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20262                 }
20263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20265         }
20266         return NDR_ERR_SUCCESS;
20267 }
20268
20269 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20270 {
20271         uint32_t _ptr_server;
20272         uint32_t _ptr_buffer;
20273         uint32_t _ptr_info;
20274         TALLOC_CTX *_mem_save_server_0;
20275         TALLOC_CTX *_mem_save_buffer_0;
20276         TALLOC_CTX *_mem_save_info_0;
20277         TALLOC_CTX *_mem_save_needed_0;
20278         TALLOC_CTX *_mem_save_count_0;
20279         if (flags & NDR_IN) {
20280                 ZERO_STRUCT(r->out);
20281
20282                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20283                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20284                 if (_ptr_server) {
20285                         NDR_PULL_ALLOC(ndr, r->in.server);
20286                 } else {
20287                         r->in.server = NULL;
20288                 }
20289                 if (r->in.server) {
20290                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20291                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20294                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20295                                 return 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));
20296                         }
20297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20300                 }
20301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20303                 if (_ptr_buffer) {
20304                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20305                 } else {
20306                         r->in.buffer = NULL;
20307                 }
20308                 if (r->in.buffer) {
20309                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20310                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20311                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20313                 }
20314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20315                 NDR_PULL_ALLOC(ndr, r->out.needed);
20316                 ZERO_STRUCTP(r->out.needed);
20317                 NDR_PULL_ALLOC(ndr, r->out.count);
20318                 ZERO_STRUCTP(r->out.count);
20319         }
20320         if (flags & NDR_OUT) {
20321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20322                 if (_ptr_info) {
20323                         NDR_PULL_ALLOC(ndr, r->out.info);
20324                 } else {
20325                         r->out.info = NULL;
20326                 }
20327                 if (r->out.info) {
20328                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20329                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20330                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20332                 }
20333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20334                         NDR_PULL_ALLOC(ndr, r->out.needed);
20335                 }
20336                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20337                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20340                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20341                         NDR_PULL_ALLOC(ndr, r->out.count);
20342                 }
20343                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20344                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20346                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20347                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20348         }
20349         return NDR_ERR_SUCCESS;
20350 }
20351
20352 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20353 {
20354         uint32_t cntr_info_0;
20355         if (flags & NDR_IN) {
20356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20358         }
20359         if (flags & NDR_OUT) {
20360                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20361                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20362                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20363                 }
20364                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20365                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20366                 }
20367         }
20368         return NDR_ERR_SUCCESS;
20369 }
20370
20371 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20372 {
20373         uint32_t cntr_info_0;
20374         TALLOC_CTX *_mem_save_info_0;
20375         if (flags & NDR_IN) {
20376                 ZERO_STRUCT(r->out);
20377
20378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20379                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20380         }
20381         if (flags & NDR_OUT) {
20382                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20383                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20385                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20386                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20387                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20388                 }
20389                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20390                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20391                 }
20392                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20393         }
20394         return NDR_ERR_SUCCESS;
20395 }
20396
20397 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20398 {
20399         uint32_t cntr_info_2;
20400         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20401         ndr->depth++;
20402         if (flags & NDR_SET_VALUES) {
20403                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20404         }
20405         if (flags & NDR_IN) {
20406                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20407                 ndr->depth++;
20408                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20409                 ndr_print_ptr(ndr, "server", r->in.server);
20410                 ndr->depth++;
20411                 if (r->in.server) {
20412                         ndr_print_string(ndr, "server", r->in.server);
20413                 }
20414                 ndr->depth--;
20415                 ndr_print_uint32(ndr, "level", r->in.level);
20416                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20417                 ndr->depth++;
20418                 if (r->in.buffer) {
20419                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20420                 }
20421                 ndr->depth--;
20422                 ndr_print_uint32(ndr, "offered", r->in.offered);
20423                 ndr->depth--;
20424         }
20425         if (flags & NDR_OUT) {
20426                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20427                 ndr->depth++;
20428                 ndr_print_ptr(ndr, "count", r->out.count);
20429                 ndr->depth++;
20430                 ndr_print_uint32(ndr, "count", *r->out.count);
20431                 ndr->depth--;
20432                 ndr_print_ptr(ndr, "info", r->out.info);
20433                 ndr->depth++;
20434                 ndr_print_ptr(ndr, "info", *r->out.info);
20435                 ndr->depth++;
20436                 if (*r->out.info) {
20437                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20438                         ndr->depth++;
20439                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20440                                 char *idx_2=NULL;
20441                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20442                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20443                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20444                                         free(idx_2);
20445                                 }
20446                         }
20447                         ndr->depth--;
20448                 }
20449                 ndr->depth--;
20450                 ndr->depth--;
20451                 ndr_print_ptr(ndr, "needed", r->out.needed);
20452                 ndr->depth++;
20453                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20454                 ndr->depth--;
20455                 ndr_print_WERROR(ndr, "result", r->out.result);
20456                 ndr->depth--;
20457         }
20458         ndr->depth--;
20459 }
20460
20461 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20462 {
20463         if (flags & NDR_IN) {
20464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20465                 if (r->in.printername) {
20466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20469                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20470                 }
20471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20472                 if (r->in.datatype) {
20473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20477                 }
20478                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20479                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20480         }
20481         if (flags & NDR_OUT) {
20482                 if (r->out.handle == NULL) {
20483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20484                 }
20485                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20486                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20487         }
20488         return NDR_ERR_SUCCESS;
20489 }
20490
20491 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20492 {
20493         uint32_t _ptr_printername;
20494         uint32_t _ptr_datatype;
20495         TALLOC_CTX *_mem_save_printername_0;
20496         TALLOC_CTX *_mem_save_datatype_0;
20497         TALLOC_CTX *_mem_save_handle_0;
20498         if (flags & NDR_IN) {
20499                 ZERO_STRUCT(r->out);
20500
20501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20502                 if (_ptr_printername) {
20503                         NDR_PULL_ALLOC(ndr, r->in.printername);
20504                 } else {
20505                         r->in.printername = NULL;
20506                 }
20507                 if (r->in.printername) {
20508                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20509                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20512                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20513                                 return 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));
20514                         }
20515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20518                 }
20519                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20520                 if (_ptr_datatype) {
20521                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20522                 } else {
20523                         r->in.datatype = NULL;
20524                 }
20525                 if (r->in.datatype) {
20526                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20527                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20530                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20531                                 return 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));
20532                         }
20533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20536                 }
20537                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20538                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20539                 NDR_PULL_ALLOC(ndr, r->out.handle);
20540                 ZERO_STRUCTP(r->out.handle);
20541         }
20542         if (flags & NDR_OUT) {
20543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20544                         NDR_PULL_ALLOC(ndr, r->out.handle);
20545                 }
20546                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20547                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20548                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20550                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20551         }
20552         return NDR_ERR_SUCCESS;
20553 }
20554
20555 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20556 {
20557         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20558         ndr->depth++;
20559         if (flags & NDR_SET_VALUES) {
20560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20561         }
20562         if (flags & NDR_IN) {
20563                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20564                 ndr->depth++;
20565                 ndr_print_ptr(ndr, "printername", r->in.printername);
20566                 ndr->depth++;
20567                 if (r->in.printername) {
20568                         ndr_print_string(ndr, "printername", r->in.printername);
20569                 }
20570                 ndr->depth--;
20571                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20572                 ndr->depth++;
20573                 if (r->in.datatype) {
20574                         ndr_print_string(ndr, "datatype", r->in.datatype);
20575                 }
20576                 ndr->depth--;
20577                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20578                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20579                 ndr->depth--;
20580         }
20581         if (flags & NDR_OUT) {
20582                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20583                 ndr->depth++;
20584                 ndr_print_ptr(ndr, "handle", r->out.handle);
20585                 ndr->depth++;
20586                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20587                 ndr->depth--;
20588                 ndr_print_WERROR(ndr, "result", r->out.result);
20589                 ndr->depth--;
20590         }
20591         ndr->depth--;
20592 }
20593
20594 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20595 {
20596         if (flags & NDR_IN) {
20597                 if (r->in.handle == NULL) {
20598                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20599                 }
20600                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20603                 if (r->in.ctr) {
20604                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20605                 }
20606                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20607         }
20608         if (flags & NDR_OUT) {
20609                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20610         }
20611         return NDR_ERR_SUCCESS;
20612 }
20613
20614 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20615 {
20616         uint32_t _ptr_ctr;
20617         TALLOC_CTX *_mem_save_handle_0;
20618         TALLOC_CTX *_mem_save_ctr_0;
20619         if (flags & NDR_IN) {
20620                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20621                         NDR_PULL_ALLOC(ndr, r->in.handle);
20622                 }
20623                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20624                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20625                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20626                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20629                 if (_ptr_ctr) {
20630                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20631                 } else {
20632                         r->in.ctr = NULL;
20633                 }
20634                 if (r->in.ctr) {
20635                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20636                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20637                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20639                 }
20640                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20641         }
20642         if (flags & NDR_OUT) {
20643                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20644         }
20645         return NDR_ERR_SUCCESS;
20646 }
20647
20648 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20649 {
20650         ndr_print_struct(ndr, name, "spoolss_SetJob");
20651         ndr->depth++;
20652         if (flags & NDR_SET_VALUES) {
20653                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20654         }
20655         if (flags & NDR_IN) {
20656                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20657                 ndr->depth++;
20658                 ndr_print_ptr(ndr, "handle", r->in.handle);
20659                 ndr->depth++;
20660                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20661                 ndr->depth--;
20662                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20663                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20664                 ndr->depth++;
20665                 if (r->in.ctr) {
20666                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20667                 }
20668                 ndr->depth--;
20669                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20670                 ndr->depth--;
20671         }
20672         if (flags & NDR_OUT) {
20673                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20674                 ndr->depth++;
20675                 ndr_print_WERROR(ndr, "result", r->out.result);
20676                 ndr->depth--;
20677         }
20678         ndr->depth--;
20679 }
20680
20681 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20682 {
20683         if (flags & NDR_IN) {
20684                 if (r->in.handle == NULL) {
20685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20686                 }
20687                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20691                 if (r->in.buffer) {
20692                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20693                 }
20694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20695         }
20696         if (flags & NDR_OUT) {
20697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20698                 if (r->out.info) {
20699                         {
20700                                 struct ndr_push *_ndr_info;
20701                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20702                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20703                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20704                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20705                         }
20706                 }
20707                 if (r->out.needed == NULL) {
20708                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20709                 }
20710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20711                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20712         }
20713         return NDR_ERR_SUCCESS;
20714 }
20715
20716 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20717 {
20718         uint32_t _ptr_buffer;
20719         uint32_t _ptr_info;
20720         TALLOC_CTX *_mem_save_handle_0;
20721         TALLOC_CTX *_mem_save_buffer_0;
20722         TALLOC_CTX *_mem_save_info_0;
20723         TALLOC_CTX *_mem_save_needed_0;
20724         if (flags & NDR_IN) {
20725                 ZERO_STRUCT(r->out);
20726
20727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20728                         NDR_PULL_ALLOC(ndr, r->in.handle);
20729                 }
20730                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20732                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20737                 if (_ptr_buffer) {
20738                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20739                 } else {
20740                         r->in.buffer = NULL;
20741                 }
20742                 if (r->in.buffer) {
20743                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20745                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20747                 }
20748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20749                 NDR_PULL_ALLOC(ndr, r->out.needed);
20750                 ZERO_STRUCTP(r->out.needed);
20751         }
20752         if (flags & NDR_OUT) {
20753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20754                 if (_ptr_info) {
20755                         NDR_PULL_ALLOC(ndr, r->out.info);
20756                 } else {
20757                         r->out.info = NULL;
20758                 }
20759                 if (r->out.info) {
20760                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20761                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20762                         {
20763                                 struct ndr_pull *_ndr_info;
20764                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20765                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20766                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20767                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20768                         }
20769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20770                 }
20771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20772                         NDR_PULL_ALLOC(ndr, r->out.needed);
20773                 }
20774                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20775                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20778                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20779         }
20780         return NDR_ERR_SUCCESS;
20781 }
20782
20783 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20784 {
20785         ndr_print_struct(ndr, name, "spoolss_GetJob");
20786         ndr->depth++;
20787         if (flags & NDR_SET_VALUES) {
20788                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20789         }
20790         if (flags & NDR_IN) {
20791                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20792                 ndr->depth++;
20793                 ndr_print_ptr(ndr, "handle", r->in.handle);
20794                 ndr->depth++;
20795                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20796                 ndr->depth--;
20797                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20798                 ndr_print_uint32(ndr, "level", r->in.level);
20799                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20800                 ndr->depth++;
20801                 if (r->in.buffer) {
20802                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20803                 }
20804                 ndr->depth--;
20805                 ndr_print_uint32(ndr, "offered", r->in.offered);
20806                 ndr->depth--;
20807         }
20808         if (flags & NDR_OUT) {
20809                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20810                 ndr->depth++;
20811                 ndr_print_ptr(ndr, "info", r->out.info);
20812                 ndr->depth++;
20813                 if (r->out.info) {
20814                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20815                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20816                 }
20817                 ndr->depth--;
20818                 ndr_print_ptr(ndr, "needed", r->out.needed);
20819                 ndr->depth++;
20820                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20821                 ndr->depth--;
20822                 ndr_print_WERROR(ndr, "result", r->out.result);
20823                 ndr->depth--;
20824         }
20825         ndr->depth--;
20826 }
20827
20828 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20829 {
20830         if (flags & NDR_IN) {
20831                 if (r->in.handle == NULL) {
20832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20833                 }
20834                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20838                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20839                 if (r->in.buffer) {
20840                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20841                 }
20842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20843         }
20844         if (flags & NDR_OUT) {
20845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20846                 if (r->out.info) {
20847                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20848                 }
20849                 if (r->out.needed == NULL) {
20850                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20851                 }
20852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20853                 if (r->out.count == NULL) {
20854                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20855                 }
20856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20857                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20858         }
20859         return NDR_ERR_SUCCESS;
20860 }
20861
20862 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20863 {
20864         uint32_t _ptr_buffer;
20865         uint32_t _ptr_info;
20866         TALLOC_CTX *_mem_save_handle_0;
20867         TALLOC_CTX *_mem_save_buffer_0;
20868         TALLOC_CTX *_mem_save_info_0;
20869         TALLOC_CTX *_mem_save_needed_0;
20870         TALLOC_CTX *_mem_save_count_0;
20871         if (flags & NDR_IN) {
20872                 ZERO_STRUCT(r->out);
20873
20874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20875                         NDR_PULL_ALLOC(ndr, r->in.handle);
20876                 }
20877                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20878                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20879                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20885                 if (_ptr_buffer) {
20886                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20887                 } else {
20888                         r->in.buffer = NULL;
20889                 }
20890                 if (r->in.buffer) {
20891                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20893                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20895                 }
20896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20897                 NDR_PULL_ALLOC(ndr, r->out.needed);
20898                 ZERO_STRUCTP(r->out.needed);
20899                 NDR_PULL_ALLOC(ndr, r->out.count);
20900                 ZERO_STRUCTP(r->out.count);
20901         }
20902         if (flags & NDR_OUT) {
20903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20904                 if (_ptr_info) {
20905                         NDR_PULL_ALLOC(ndr, r->out.info);
20906                 } else {
20907                         r->out.info = NULL;
20908                 }
20909                 if (r->out.info) {
20910                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20911                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20912                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20914                 }
20915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20916                         NDR_PULL_ALLOC(ndr, r->out.needed);
20917                 }
20918                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20919                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20922                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20923                         NDR_PULL_ALLOC(ndr, r->out.count);
20924                 }
20925                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20926                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20929                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20930         }
20931         return NDR_ERR_SUCCESS;
20932 }
20933
20934 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20935 {
20936         uint32_t cntr_info_0;
20937         if (flags & NDR_IN) {
20938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20940         }
20941         if (flags & NDR_OUT) {
20942                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20943                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20944                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20945                 }
20946                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20947                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20948                 }
20949         }
20950         return NDR_ERR_SUCCESS;
20951 }
20952
20953 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20954 {
20955         uint32_t cntr_info_0;
20956         TALLOC_CTX *_mem_save_info_0;
20957         if (flags & NDR_IN) {
20958                 ZERO_STRUCT(r->out);
20959
20960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20962         }
20963         if (flags & NDR_OUT) {
20964                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20965                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20966                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20967                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20968                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20969                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20970                 }
20971                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20972                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20973                 }
20974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20975         }
20976         return NDR_ERR_SUCCESS;
20977 }
20978
20979 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20980 {
20981         uint32_t cntr_info_2;
20982         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20983         ndr->depth++;
20984         if (flags & NDR_SET_VALUES) {
20985                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20986         }
20987         if (flags & NDR_IN) {
20988                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20989                 ndr->depth++;
20990                 ndr_print_ptr(ndr, "handle", r->in.handle);
20991                 ndr->depth++;
20992                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20993                 ndr->depth--;
20994                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20995                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20996                 ndr_print_uint32(ndr, "level", r->in.level);
20997                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20998                 ndr->depth++;
20999                 if (r->in.buffer) {
21000                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21001                 }
21002                 ndr->depth--;
21003                 ndr_print_uint32(ndr, "offered", r->in.offered);
21004                 ndr->depth--;
21005         }
21006         if (flags & NDR_OUT) {
21007                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21008                 ndr->depth++;
21009                 ndr_print_ptr(ndr, "count", r->out.count);
21010                 ndr->depth++;
21011                 ndr_print_uint32(ndr, "count", *r->out.count);
21012                 ndr->depth--;
21013                 ndr_print_ptr(ndr, "info", r->out.info);
21014                 ndr->depth++;
21015                 ndr_print_ptr(ndr, "info", *r->out.info);
21016                 ndr->depth++;
21017                 if (*r->out.info) {
21018                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21019                         ndr->depth++;
21020                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21021                                 char *idx_2=NULL;
21022                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21023                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21024                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21025                                         free(idx_2);
21026                                 }
21027                         }
21028                         ndr->depth--;
21029                 }
21030                 ndr->depth--;
21031                 ndr->depth--;
21032                 ndr_print_ptr(ndr, "needed", r->out.needed);
21033                 ndr->depth++;
21034                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21035                 ndr->depth--;
21036                 ndr_print_WERROR(ndr, "result", r->out.result);
21037                 ndr->depth--;
21038         }
21039         ndr->depth--;
21040 }
21041
21042 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21043 {
21044         if (flags & NDR_IN) {
21045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21046                 if (r->in.server) {
21047                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21048                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21051                 }
21052                 if (r->in.info_ctr == NULL) {
21053                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21054                 }
21055                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21056                 if (r->in.devmode_ctr == NULL) {
21057                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21058                 }
21059                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21060                 if (r->in.secdesc_ctr == NULL) {
21061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21062                 }
21063                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21064         }
21065         if (flags & NDR_OUT) {
21066                 if (r->out.handle == NULL) {
21067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21068                 }
21069                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21070                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21071         }
21072         return NDR_ERR_SUCCESS;
21073 }
21074
21075 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21076 {
21077         uint32_t _ptr_server;
21078         TALLOC_CTX *_mem_save_server_0;
21079         TALLOC_CTX *_mem_save_info_ctr_0;
21080         TALLOC_CTX *_mem_save_devmode_ctr_0;
21081         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21082         TALLOC_CTX *_mem_save_handle_0;
21083         if (flags & NDR_IN) {
21084                 ZERO_STRUCT(r->out);
21085
21086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21087                 if (_ptr_server) {
21088                         NDR_PULL_ALLOC(ndr, r->in.server);
21089                 } else {
21090                         r->in.server = NULL;
21091                 }
21092                 if (r->in.server) {
21093                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21094                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21096                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21097                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21098                                 return 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));
21099                         }
21100                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21101                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21103                 }
21104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21105                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21106                 }
21107                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21108                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21109                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21111                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21112                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21113                 }
21114                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21115                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21116                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21119                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21120                 }
21121                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21123                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21125                 NDR_PULL_ALLOC(ndr, r->out.handle);
21126                 ZERO_STRUCTP(r->out.handle);
21127         }
21128         if (flags & NDR_OUT) {
21129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21130                         NDR_PULL_ALLOC(ndr, r->out.handle);
21131                 }
21132                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21133                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21134                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21136                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21137         }
21138         return NDR_ERR_SUCCESS;
21139 }
21140
21141 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21142 {
21143         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21144         ndr->depth++;
21145         if (flags & NDR_SET_VALUES) {
21146                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21147         }
21148         if (flags & NDR_IN) {
21149                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21150                 ndr->depth++;
21151                 ndr_print_ptr(ndr, "server", r->in.server);
21152                 ndr->depth++;
21153                 if (r->in.server) {
21154                         ndr_print_string(ndr, "server", r->in.server);
21155                 }
21156                 ndr->depth--;
21157                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21158                 ndr->depth++;
21159                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21160                 ndr->depth--;
21161                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21162                 ndr->depth++;
21163                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21164                 ndr->depth--;
21165                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21166                 ndr->depth++;
21167                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21168                 ndr->depth--;
21169                 ndr->depth--;
21170         }
21171         if (flags & NDR_OUT) {
21172                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21173                 ndr->depth++;
21174                 ndr_print_ptr(ndr, "handle", r->out.handle);
21175                 ndr->depth++;
21176                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21177                 ndr->depth--;
21178                 ndr_print_WERROR(ndr, "result", r->out.result);
21179                 ndr->depth--;
21180         }
21181         ndr->depth--;
21182 }
21183
21184 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21185 {
21186         if (flags & NDR_IN) {
21187                 if (r->in.handle == NULL) {
21188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21189                 }
21190                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21191         }
21192         if (flags & NDR_OUT) {
21193                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21194         }
21195         return NDR_ERR_SUCCESS;
21196 }
21197
21198 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21199 {
21200         TALLOC_CTX *_mem_save_handle_0;
21201         if (flags & NDR_IN) {
21202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21203                         NDR_PULL_ALLOC(ndr, r->in.handle);
21204                 }
21205                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21206                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21207                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21209         }
21210         if (flags & NDR_OUT) {
21211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21212         }
21213         return NDR_ERR_SUCCESS;
21214 }
21215
21216 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21217 {
21218         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21219         ndr->depth++;
21220         if (flags & NDR_SET_VALUES) {
21221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21222         }
21223         if (flags & NDR_IN) {
21224                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21225                 ndr->depth++;
21226                 ndr_print_ptr(ndr, "handle", r->in.handle);
21227                 ndr->depth++;
21228                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21229                 ndr->depth--;
21230                 ndr->depth--;
21231         }
21232         if (flags & NDR_OUT) {
21233                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21234                 ndr->depth++;
21235                 ndr_print_WERROR(ndr, "result", r->out.result);
21236                 ndr->depth--;
21237         }
21238         ndr->depth--;
21239 }
21240
21241 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21242 {
21243         if (flags & NDR_IN) {
21244                 if (r->in.handle == NULL) {
21245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21246                 }
21247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21248                 if (r->in.info_ctr == NULL) {
21249                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21250                 }
21251                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21252                 if (r->in.devmode_ctr == NULL) {
21253                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21254                 }
21255                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21256                 if (r->in.secdesc_ctr == NULL) {
21257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21258                 }
21259                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21260                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21261         }
21262         if (flags & NDR_OUT) {
21263                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21264         }
21265         return NDR_ERR_SUCCESS;
21266 }
21267
21268 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21269 {
21270         TALLOC_CTX *_mem_save_handle_0;
21271         TALLOC_CTX *_mem_save_info_ctr_0;
21272         TALLOC_CTX *_mem_save_devmode_ctr_0;
21273         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21274         if (flags & NDR_IN) {
21275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21276                         NDR_PULL_ALLOC(ndr, r->in.handle);
21277                 }
21278                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21279                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21280                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21283                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21284                 }
21285                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21287                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21290                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21291                 }
21292                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21294                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21296                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21297                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21298                 }
21299                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21300                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21301                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21302                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21303                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21304         }
21305         if (flags & NDR_OUT) {
21306                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21307         }
21308         return NDR_ERR_SUCCESS;
21309 }
21310
21311 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21312 {
21313         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21314         ndr->depth++;
21315         if (flags & NDR_SET_VALUES) {
21316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21317         }
21318         if (flags & NDR_IN) {
21319                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21320                 ndr->depth++;
21321                 ndr_print_ptr(ndr, "handle", r->in.handle);
21322                 ndr->depth++;
21323                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21324                 ndr->depth--;
21325                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21326                 ndr->depth++;
21327                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21328                 ndr->depth--;
21329                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21330                 ndr->depth++;
21331                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21332                 ndr->depth--;
21333                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21334                 ndr->depth++;
21335                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21336                 ndr->depth--;
21337                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21338                 ndr->depth--;
21339         }
21340         if (flags & NDR_OUT) {
21341                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21342                 ndr->depth++;
21343                 ndr_print_WERROR(ndr, "result", r->out.result);
21344                 ndr->depth--;
21345         }
21346         ndr->depth--;
21347 }
21348
21349 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21350 {
21351         if (flags & NDR_IN) {
21352                 if (r->in.handle == NULL) {
21353                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21354                 }
21355                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21358                 if (r->in.buffer) {
21359                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21360                 }
21361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21362         }
21363         if (flags & NDR_OUT) {
21364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21365                 if (r->out.info) {
21366                         {
21367                                 struct ndr_push *_ndr_info;
21368                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21369                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21370                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21371                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21372                         }
21373                 }
21374                 if (r->out.needed == NULL) {
21375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21376                 }
21377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21378                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21379         }
21380         return NDR_ERR_SUCCESS;
21381 }
21382
21383 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21384 {
21385         uint32_t _ptr_buffer;
21386         uint32_t _ptr_info;
21387         TALLOC_CTX *_mem_save_handle_0;
21388         TALLOC_CTX *_mem_save_buffer_0;
21389         TALLOC_CTX *_mem_save_info_0;
21390         TALLOC_CTX *_mem_save_needed_0;
21391         if (flags & NDR_IN) {
21392                 ZERO_STRUCT(r->out);
21393
21394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21395                         NDR_PULL_ALLOC(ndr, r->in.handle);
21396                 }
21397                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21398                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21399                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21403                 if (_ptr_buffer) {
21404                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21405                 } else {
21406                         r->in.buffer = NULL;
21407                 }
21408                 if (r->in.buffer) {
21409                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21410                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21411                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21412                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21413                 }
21414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21415                 NDR_PULL_ALLOC(ndr, r->out.needed);
21416                 ZERO_STRUCTP(r->out.needed);
21417         }
21418         if (flags & NDR_OUT) {
21419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21420                 if (_ptr_info) {
21421                         NDR_PULL_ALLOC(ndr, r->out.info);
21422                 } else {
21423                         r->out.info = NULL;
21424                 }
21425                 if (r->out.info) {
21426                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21427                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21428                         {
21429                                 struct ndr_pull *_ndr_info;
21430                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21431                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21432                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21433                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21434                         }
21435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21436                 }
21437                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21438                         NDR_PULL_ALLOC(ndr, r->out.needed);
21439                 }
21440                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21441                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21443                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21444                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21445         }
21446         return NDR_ERR_SUCCESS;
21447 }
21448
21449 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21450 {
21451         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21452         ndr->depth++;
21453         if (flags & NDR_SET_VALUES) {
21454                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21455         }
21456         if (flags & NDR_IN) {
21457                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21458                 ndr->depth++;
21459                 ndr_print_ptr(ndr, "handle", r->in.handle);
21460                 ndr->depth++;
21461                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21462                 ndr->depth--;
21463                 ndr_print_uint32(ndr, "level", r->in.level);
21464                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21465                 ndr->depth++;
21466                 if (r->in.buffer) {
21467                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21468                 }
21469                 ndr->depth--;
21470                 ndr_print_uint32(ndr, "offered", r->in.offered);
21471                 ndr->depth--;
21472         }
21473         if (flags & NDR_OUT) {
21474                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21475                 ndr->depth++;
21476                 ndr_print_ptr(ndr, "info", r->out.info);
21477                 ndr->depth++;
21478                 if (r->out.info) {
21479                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21480                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21481                 }
21482                 ndr->depth--;
21483                 ndr_print_ptr(ndr, "needed", r->out.needed);
21484                 ndr->depth++;
21485                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21486                 ndr->depth--;
21487                 ndr_print_WERROR(ndr, "result", r->out.result);
21488                 ndr->depth--;
21489         }
21490         ndr->depth--;
21491 }
21492
21493 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21494 {
21495         if (flags & NDR_IN) {
21496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21497                 if (r->in.servername) {
21498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21499                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21500                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21501                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21502                 }
21503                 if (r->in.info_ctr == NULL) {
21504                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21505                 }
21506                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21507         }
21508         if (flags & NDR_OUT) {
21509                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21510         }
21511         return NDR_ERR_SUCCESS;
21512 }
21513
21514 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21515 {
21516         uint32_t _ptr_servername;
21517         TALLOC_CTX *_mem_save_servername_0;
21518         TALLOC_CTX *_mem_save_info_ctr_0;
21519         if (flags & NDR_IN) {
21520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21521                 if (_ptr_servername) {
21522                         NDR_PULL_ALLOC(ndr, r->in.servername);
21523                 } else {
21524                         r->in.servername = NULL;
21525                 }
21526                 if (r->in.servername) {
21527                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21531                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21532                                 return 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));
21533                         }
21534                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21537                 }
21538                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21539                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21540                 }
21541                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21542                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21543                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21544                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21545         }
21546         if (flags & NDR_OUT) {
21547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21548         }
21549         return NDR_ERR_SUCCESS;
21550 }
21551
21552 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21553 {
21554         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21555         ndr->depth++;
21556         if (flags & NDR_SET_VALUES) {
21557                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21558         }
21559         if (flags & NDR_IN) {
21560                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21561                 ndr->depth++;
21562                 ndr_print_ptr(ndr, "servername", r->in.servername);
21563                 ndr->depth++;
21564                 if (r->in.servername) {
21565                         ndr_print_string(ndr, "servername", r->in.servername);
21566                 }
21567                 ndr->depth--;
21568                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21569                 ndr->depth++;
21570                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21571                 ndr->depth--;
21572                 ndr->depth--;
21573         }
21574         if (flags & NDR_OUT) {
21575                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21576                 ndr->depth++;
21577                 ndr_print_WERROR(ndr, "result", r->out.result);
21578                 ndr->depth--;
21579         }
21580         ndr->depth--;
21581 }
21582
21583 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21584 {
21585         if (flags & NDR_IN) {
21586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21587                 if (r->in.server) {
21588                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21589                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21592                 }
21593                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21594                 if (r->in.environment) {
21595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21596                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21598                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21599                 }
21600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21602                 if (r->in.buffer) {
21603                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21604                 }
21605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21606         }
21607         if (flags & NDR_OUT) {
21608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21609                 if (r->out.info) {
21610                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21611                 }
21612                 if (r->out.needed == NULL) {
21613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21614                 }
21615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21616                 if (r->out.count == NULL) {
21617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21618                 }
21619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21621         }
21622         return NDR_ERR_SUCCESS;
21623 }
21624
21625 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21626 {
21627         uint32_t _ptr_server;
21628         uint32_t _ptr_environment;
21629         uint32_t _ptr_buffer;
21630         uint32_t _ptr_info;
21631         TALLOC_CTX *_mem_save_server_0;
21632         TALLOC_CTX *_mem_save_environment_0;
21633         TALLOC_CTX *_mem_save_buffer_0;
21634         TALLOC_CTX *_mem_save_info_0;
21635         TALLOC_CTX *_mem_save_needed_0;
21636         TALLOC_CTX *_mem_save_count_0;
21637         if (flags & NDR_IN) {
21638                 ZERO_STRUCT(r->out);
21639
21640                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21641                 if (_ptr_server) {
21642                         NDR_PULL_ALLOC(ndr, r->in.server);
21643                 } else {
21644                         r->in.server = NULL;
21645                 }
21646                 if (r->in.server) {
21647                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21648                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21650                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21651                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21652                                 return 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));
21653                         }
21654                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21655                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21656                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21657                 }
21658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21659                 if (_ptr_environment) {
21660                         NDR_PULL_ALLOC(ndr, r->in.environment);
21661                 } else {
21662                         r->in.environment = NULL;
21663                 }
21664                 if (r->in.environment) {
21665                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21666                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21669                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21670                                 return 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));
21671                         }
21672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21675                 }
21676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21677                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21678                 if (_ptr_buffer) {
21679                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21680                 } else {
21681                         r->in.buffer = NULL;
21682                 }
21683                 if (r->in.buffer) {
21684                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21685                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21686                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21688                 }
21689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21690                 NDR_PULL_ALLOC(ndr, r->out.needed);
21691                 ZERO_STRUCTP(r->out.needed);
21692                 NDR_PULL_ALLOC(ndr, r->out.count);
21693                 ZERO_STRUCTP(r->out.count);
21694         }
21695         if (flags & NDR_OUT) {
21696                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21697                 if (_ptr_info) {
21698                         NDR_PULL_ALLOC(ndr, r->out.info);
21699                 } else {
21700                         r->out.info = NULL;
21701                 }
21702                 if (r->out.info) {
21703                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21704                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21705                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21707                 }
21708                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21709                         NDR_PULL_ALLOC(ndr, r->out.needed);
21710                 }
21711                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21712                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21715                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21716                         NDR_PULL_ALLOC(ndr, r->out.count);
21717                 }
21718                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21719                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21721                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21723         }
21724         return NDR_ERR_SUCCESS;
21725 }
21726
21727 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21728 {
21729         uint32_t cntr_info_0;
21730         if (flags & NDR_IN) {
21731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21733         }
21734         if (flags & NDR_OUT) {
21735                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21736                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21737                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21738                 }
21739                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21740                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21741                 }
21742         }
21743         return NDR_ERR_SUCCESS;
21744 }
21745
21746 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21747 {
21748         uint32_t cntr_info_0;
21749         TALLOC_CTX *_mem_save_info_0;
21750         if (flags & NDR_IN) {
21751                 ZERO_STRUCT(r->out);
21752
21753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21755         }
21756         if (flags & NDR_OUT) {
21757                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21758                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21759                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21760                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21761                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21762                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21763                 }
21764                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21765                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21766                 }
21767                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21768         }
21769         return NDR_ERR_SUCCESS;
21770 }
21771
21772 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21773 {
21774         uint32_t cntr_info_2;
21775         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21776         ndr->depth++;
21777         if (flags & NDR_SET_VALUES) {
21778                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21779         }
21780         if (flags & NDR_IN) {
21781                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21782                 ndr->depth++;
21783                 ndr_print_ptr(ndr, "server", r->in.server);
21784                 ndr->depth++;
21785                 if (r->in.server) {
21786                         ndr_print_string(ndr, "server", r->in.server);
21787                 }
21788                 ndr->depth--;
21789                 ndr_print_ptr(ndr, "environment", r->in.environment);
21790                 ndr->depth++;
21791                 if (r->in.environment) {
21792                         ndr_print_string(ndr, "environment", r->in.environment);
21793                 }
21794                 ndr->depth--;
21795                 ndr_print_uint32(ndr, "level", r->in.level);
21796                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21797                 ndr->depth++;
21798                 if (r->in.buffer) {
21799                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21800                 }
21801                 ndr->depth--;
21802                 ndr_print_uint32(ndr, "offered", r->in.offered);
21803                 ndr->depth--;
21804         }
21805         if (flags & NDR_OUT) {
21806                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21807                 ndr->depth++;
21808                 ndr_print_ptr(ndr, "count", r->out.count);
21809                 ndr->depth++;
21810                 ndr_print_uint32(ndr, "count", *r->out.count);
21811                 ndr->depth--;
21812                 ndr_print_ptr(ndr, "info", r->out.info);
21813                 ndr->depth++;
21814                 ndr_print_ptr(ndr, "info", *r->out.info);
21815                 ndr->depth++;
21816                 if (*r->out.info) {
21817                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21818                         ndr->depth++;
21819                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21820                                 char *idx_2=NULL;
21821                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21822                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21823                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21824                                         free(idx_2);
21825                                 }
21826                         }
21827                         ndr->depth--;
21828                 }
21829                 ndr->depth--;
21830                 ndr->depth--;
21831                 ndr_print_ptr(ndr, "needed", r->out.needed);
21832                 ndr->depth++;
21833                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21834                 ndr->depth--;
21835                 ndr_print_WERROR(ndr, "result", r->out.result);
21836                 ndr->depth--;
21837         }
21838         ndr->depth--;
21839 }
21840
21841 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21842 {
21843         if (flags & NDR_IN) {
21844                 if (r->in.handle == NULL) {
21845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21846                 }
21847                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21849                 if (r->in.architecture) {
21850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21854                 }
21855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21857                 if (r->in.buffer) {
21858                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21859                 }
21860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21861         }
21862         if (flags & NDR_OUT) {
21863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21864                 if (r->out.info) {
21865                         {
21866                                 struct ndr_push *_ndr_info;
21867                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21868                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21869                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21870                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21871                         }
21872                 }
21873                 if (r->out.needed == NULL) {
21874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21875                 }
21876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21878         }
21879         return NDR_ERR_SUCCESS;
21880 }
21881
21882 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21883 {
21884         uint32_t _ptr_architecture;
21885         uint32_t _ptr_buffer;
21886         uint32_t _ptr_info;
21887         TALLOC_CTX *_mem_save_handle_0;
21888         TALLOC_CTX *_mem_save_architecture_0;
21889         TALLOC_CTX *_mem_save_buffer_0;
21890         TALLOC_CTX *_mem_save_info_0;
21891         TALLOC_CTX *_mem_save_needed_0;
21892         if (flags & NDR_IN) {
21893                 ZERO_STRUCT(r->out);
21894
21895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21896                         NDR_PULL_ALLOC(ndr, r->in.handle);
21897                 }
21898                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21903                 if (_ptr_architecture) {
21904                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21905                 } else {
21906                         r->in.architecture = NULL;
21907                 }
21908                 if (r->in.architecture) {
21909                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21910                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21913                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21914                                 return 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));
21915                         }
21916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21919                 }
21920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21922                 if (_ptr_buffer) {
21923                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21924                 } else {
21925                         r->in.buffer = NULL;
21926                 }
21927                 if (r->in.buffer) {
21928                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21929                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21930                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21932                 }
21933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21934                 NDR_PULL_ALLOC(ndr, r->out.needed);
21935                 ZERO_STRUCTP(r->out.needed);
21936         }
21937         if (flags & NDR_OUT) {
21938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21939                 if (_ptr_info) {
21940                         NDR_PULL_ALLOC(ndr, r->out.info);
21941                 } else {
21942                         r->out.info = NULL;
21943                 }
21944                 if (r->out.info) {
21945                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21946                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21947                         {
21948                                 struct ndr_pull *_ndr_info;
21949                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21950                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21951                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21952                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21953                         }
21954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21955                 }
21956                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21957                         NDR_PULL_ALLOC(ndr, r->out.needed);
21958                 }
21959                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21960                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21964         }
21965         return NDR_ERR_SUCCESS;
21966 }
21967
21968 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21969 {
21970         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21971         ndr->depth++;
21972         if (flags & NDR_SET_VALUES) {
21973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21974         }
21975         if (flags & NDR_IN) {
21976                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21977                 ndr->depth++;
21978                 ndr_print_ptr(ndr, "handle", r->in.handle);
21979                 ndr->depth++;
21980                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21981                 ndr->depth--;
21982                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21983                 ndr->depth++;
21984                 if (r->in.architecture) {
21985                         ndr_print_string(ndr, "architecture", r->in.architecture);
21986                 }
21987                 ndr->depth--;
21988                 ndr_print_uint32(ndr, "level", r->in.level);
21989                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21990                 ndr->depth++;
21991                 if (r->in.buffer) {
21992                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21993                 }
21994                 ndr->depth--;
21995                 ndr_print_uint32(ndr, "offered", r->in.offered);
21996                 ndr->depth--;
21997         }
21998         if (flags & NDR_OUT) {
21999                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22000                 ndr->depth++;
22001                 ndr_print_ptr(ndr, "info", r->out.info);
22002                 ndr->depth++;
22003                 if (r->out.info) {
22004                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22005                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22006                 }
22007                 ndr->depth--;
22008                 ndr_print_ptr(ndr, "needed", r->out.needed);
22009                 ndr->depth++;
22010                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22011                 ndr->depth--;
22012                 ndr_print_WERROR(ndr, "result", r->out.result);
22013                 ndr->depth--;
22014         }
22015         ndr->depth--;
22016 }
22017
22018 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22019 {
22020         if (flags & NDR_IN) {
22021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22022                 if (r->in.server) {
22023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22027                 }
22028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22029                 if (r->in.environment) {
22030                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22034                 }
22035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22037                 if (r->in.buffer) {
22038                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22039                 }
22040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22041         }
22042         if (flags & NDR_OUT) {
22043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22044                 if (r->out.info) {
22045                         {
22046                                 struct ndr_push *_ndr_info;
22047                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22048                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22049                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22050                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22051                         }
22052                 }
22053                 if (r->out.needed == NULL) {
22054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22055                 }
22056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22057                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22058         }
22059         return NDR_ERR_SUCCESS;
22060 }
22061
22062 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22063 {
22064         uint32_t _ptr_server;
22065         uint32_t _ptr_environment;
22066         uint32_t _ptr_buffer;
22067         uint32_t _ptr_info;
22068         TALLOC_CTX *_mem_save_server_0;
22069         TALLOC_CTX *_mem_save_environment_0;
22070         TALLOC_CTX *_mem_save_buffer_0;
22071         TALLOC_CTX *_mem_save_info_0;
22072         TALLOC_CTX *_mem_save_needed_0;
22073         if (flags & NDR_IN) {
22074                 ZERO_STRUCT(r->out);
22075
22076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22077                 if (_ptr_server) {
22078                         NDR_PULL_ALLOC(ndr, r->in.server);
22079                 } else {
22080                         r->in.server = NULL;
22081                 }
22082                 if (r->in.server) {
22083                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22084                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22087                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22088                                 return 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));
22089                         }
22090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22093                 }
22094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22095                 if (_ptr_environment) {
22096                         NDR_PULL_ALLOC(ndr, r->in.environment);
22097                 } else {
22098                         r->in.environment = NULL;
22099                 }
22100                 if (r->in.environment) {
22101                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22102                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22105                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22106                                 return 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));
22107                         }
22108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22111                 }
22112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22114                 if (_ptr_buffer) {
22115                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22116                 } else {
22117                         r->in.buffer = NULL;
22118                 }
22119                 if (r->in.buffer) {
22120                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22121                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22122                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22124                 }
22125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22126                 NDR_PULL_ALLOC(ndr, r->out.needed);
22127                 ZERO_STRUCTP(r->out.needed);
22128         }
22129         if (flags & NDR_OUT) {
22130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22131                 if (_ptr_info) {
22132                         NDR_PULL_ALLOC(ndr, r->out.info);
22133                 } else {
22134                         r->out.info = NULL;
22135                 }
22136                 if (r->out.info) {
22137                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22138                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22139                         {
22140                                 struct ndr_pull *_ndr_info;
22141                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22142                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22143                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22144                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22145                         }
22146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22147                 }
22148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22149                         NDR_PULL_ALLOC(ndr, r->out.needed);
22150                 }
22151                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22152                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22156         }
22157         return NDR_ERR_SUCCESS;
22158 }
22159
22160 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22161 {
22162         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22163         ndr->depth++;
22164         if (flags & NDR_SET_VALUES) {
22165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22166         }
22167         if (flags & NDR_IN) {
22168                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22169                 ndr->depth++;
22170                 ndr_print_ptr(ndr, "server", r->in.server);
22171                 ndr->depth++;
22172                 if (r->in.server) {
22173                         ndr_print_string(ndr, "server", r->in.server);
22174                 }
22175                 ndr->depth--;
22176                 ndr_print_ptr(ndr, "environment", r->in.environment);
22177                 ndr->depth++;
22178                 if (r->in.environment) {
22179                         ndr_print_string(ndr, "environment", r->in.environment);
22180                 }
22181                 ndr->depth--;
22182                 ndr_print_uint32(ndr, "level", r->in.level);
22183                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22184                 ndr->depth++;
22185                 if (r->in.buffer) {
22186                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22187                 }
22188                 ndr->depth--;
22189                 ndr_print_uint32(ndr, "offered", r->in.offered);
22190                 ndr->depth--;
22191         }
22192         if (flags & NDR_OUT) {
22193                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22194                 ndr->depth++;
22195                 ndr_print_ptr(ndr, "info", r->out.info);
22196                 ndr->depth++;
22197                 if (r->out.info) {
22198                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22199                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22200                 }
22201                 ndr->depth--;
22202                 ndr_print_ptr(ndr, "needed", r->out.needed);
22203                 ndr->depth++;
22204                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22205                 ndr->depth--;
22206                 ndr_print_WERROR(ndr, "result", r->out.result);
22207                 ndr->depth--;
22208         }
22209         ndr->depth--;
22210 }
22211
22212 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22213 {
22214         if (flags & NDR_IN) {
22215                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22216                 if (r->in.server) {
22217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22221                 }
22222                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22223                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22224                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22225                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22226                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22227                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22228                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22229                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22230         }
22231         if (flags & NDR_OUT) {
22232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22233         }
22234         return NDR_ERR_SUCCESS;
22235 }
22236
22237 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22238 {
22239         uint32_t _ptr_server;
22240         TALLOC_CTX *_mem_save_server_0;
22241         if (flags & NDR_IN) {
22242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22243                 if (_ptr_server) {
22244                         NDR_PULL_ALLOC(ndr, r->in.server);
22245                 } else {
22246                         r->in.server = NULL;
22247                 }
22248                 if (r->in.server) {
22249                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22250                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22253                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22254                                 return 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));
22255                         }
22256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22259                 }
22260                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22261                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22262                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22263                         return 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));
22264                 }
22265                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22266                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22267                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22268                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22269                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22270                         return 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));
22271                 }
22272                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22273                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22274         }
22275         if (flags & NDR_OUT) {
22276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22277         }
22278         return NDR_ERR_SUCCESS;
22279 }
22280
22281 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22282 {
22283         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22284         ndr->depth++;
22285         if (flags & NDR_SET_VALUES) {
22286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22287         }
22288         if (flags & NDR_IN) {
22289                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22290                 ndr->depth++;
22291                 ndr_print_ptr(ndr, "server", r->in.server);
22292                 ndr->depth++;
22293                 if (r->in.server) {
22294                         ndr_print_string(ndr, "server", r->in.server);
22295                 }
22296                 ndr->depth--;
22297                 ndr_print_string(ndr, "architecture", r->in.architecture);
22298                 ndr_print_string(ndr, "driver", r->in.driver);
22299                 ndr->depth--;
22300         }
22301         if (flags & NDR_OUT) {
22302                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22303                 ndr->depth++;
22304                 ndr_print_WERROR(ndr, "result", r->out.result);
22305                 ndr->depth--;
22306         }
22307         ndr->depth--;
22308 }
22309
22310 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22311 {
22312         if (flags & NDR_IN) {
22313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22314                 if (r->in.server) {
22315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22318                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22319                 }
22320                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22321                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22322                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22323                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22324                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22325                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22326                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22327                 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));
22328                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22329                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22330                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22331                 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));
22332         }
22333         if (flags & NDR_OUT) {
22334                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22335         }
22336         return NDR_ERR_SUCCESS;
22337 }
22338
22339 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22340 {
22341         uint32_t _ptr_server;
22342         TALLOC_CTX *_mem_save_server_0;
22343         if (flags & NDR_IN) {
22344                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22345                 if (_ptr_server) {
22346                         NDR_PULL_ALLOC(ndr, r->in.server);
22347                 } else {
22348                         r->in.server = NULL;
22349                 }
22350                 if (r->in.server) {
22351                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22352                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22353                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22354                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22355                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22356                                 return 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));
22357                         }
22358                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22361                 }
22362                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22363                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22364                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22365                         return 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));
22366                 }
22367                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22368                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22369                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22370                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22371                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22372                         return 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));
22373                 }
22374                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22375                 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));
22376                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22377                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22378                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22379                         return 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));
22380                 }
22381                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22382                 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));
22383         }
22384         if (flags & NDR_OUT) {
22385                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22386         }
22387         return NDR_ERR_SUCCESS;
22388 }
22389
22390 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22391 {
22392         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22393         ndr->depth++;
22394         if (flags & NDR_SET_VALUES) {
22395                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22396         }
22397         if (flags & NDR_IN) {
22398                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22399                 ndr->depth++;
22400                 ndr_print_ptr(ndr, "server", r->in.server);
22401                 ndr->depth++;
22402                 if (r->in.server) {
22403                         ndr_print_string(ndr, "server", r->in.server);
22404                 }
22405                 ndr->depth--;
22406                 ndr_print_string(ndr, "architecture", r->in.architecture);
22407                 ndr_print_string(ndr, "path_name", r->in.path_name);
22408                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22409                 ndr->depth--;
22410         }
22411         if (flags & NDR_OUT) {
22412                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22413                 ndr->depth++;
22414                 ndr_print_WERROR(ndr, "result", r->out.result);
22415                 ndr->depth--;
22416         }
22417         ndr->depth--;
22418 }
22419
22420 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22421 {
22422         if (flags & NDR_IN) {
22423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22424                 if (r->in.servername) {
22425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22429                 }
22430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22431                 if (r->in.environment) {
22432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22436                 }
22437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22439                 if (r->in.buffer) {
22440                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22441                 }
22442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22443         }
22444         if (flags & NDR_OUT) {
22445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22446                 if (r->out.info) {
22447                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22448                 }
22449                 if (r->out.needed == NULL) {
22450                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22451                 }
22452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22453                 if (r->out.count == NULL) {
22454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22455                 }
22456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22457                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22458         }
22459         return NDR_ERR_SUCCESS;
22460 }
22461
22462 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22463 {
22464         uint32_t _ptr_servername;
22465         uint32_t _ptr_environment;
22466         uint32_t _ptr_buffer;
22467         uint32_t _ptr_info;
22468         TALLOC_CTX *_mem_save_servername_0;
22469         TALLOC_CTX *_mem_save_environment_0;
22470         TALLOC_CTX *_mem_save_buffer_0;
22471         TALLOC_CTX *_mem_save_info_0;
22472         TALLOC_CTX *_mem_save_needed_0;
22473         TALLOC_CTX *_mem_save_count_0;
22474         if (flags & NDR_IN) {
22475                 ZERO_STRUCT(r->out);
22476
22477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22478                 if (_ptr_servername) {
22479                         NDR_PULL_ALLOC(ndr, r->in.servername);
22480                 } else {
22481                         r->in.servername = NULL;
22482                 }
22483                 if (r->in.servername) {
22484                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22485                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22488                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22489                                 return 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));
22490                         }
22491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22494                 }
22495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22496                 if (_ptr_environment) {
22497                         NDR_PULL_ALLOC(ndr, r->in.environment);
22498                 } else {
22499                         r->in.environment = NULL;
22500                 }
22501                 if (r->in.environment) {
22502                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22503                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22506                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22507                                 return 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));
22508                         }
22509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22512                 }
22513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22515                 if (_ptr_buffer) {
22516                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22517                 } else {
22518                         r->in.buffer = NULL;
22519                 }
22520                 if (r->in.buffer) {
22521                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22522                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22523                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22525                 }
22526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22527                 NDR_PULL_ALLOC(ndr, r->out.needed);
22528                 ZERO_STRUCTP(r->out.needed);
22529                 NDR_PULL_ALLOC(ndr, r->out.count);
22530                 ZERO_STRUCTP(r->out.count);
22531         }
22532         if (flags & NDR_OUT) {
22533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22534                 if (_ptr_info) {
22535                         NDR_PULL_ALLOC(ndr, r->out.info);
22536                 } else {
22537                         r->out.info = NULL;
22538                 }
22539                 if (r->out.info) {
22540                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22541                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22542                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22544                 }
22545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22546                         NDR_PULL_ALLOC(ndr, r->out.needed);
22547                 }
22548                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22549                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22553                         NDR_PULL_ALLOC(ndr, r->out.count);
22554                 }
22555                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22556                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22559                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22560         }
22561         return NDR_ERR_SUCCESS;
22562 }
22563
22564 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22565 {
22566         uint32_t cntr_info_0;
22567         if (flags & NDR_IN) {
22568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22570         }
22571         if (flags & NDR_OUT) {
22572                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22573                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22574                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22575                 }
22576                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22577                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22578                 }
22579         }
22580         return NDR_ERR_SUCCESS;
22581 }
22582
22583 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22584 {
22585         uint32_t cntr_info_0;
22586         TALLOC_CTX *_mem_save_info_0;
22587         if (flags & NDR_IN) {
22588                 ZERO_STRUCT(r->out);
22589
22590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22592         }
22593         if (flags & NDR_OUT) {
22594                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22595                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22596                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22597                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22598                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22599                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22600                 }
22601                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22602                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22603                 }
22604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22605         }
22606         return NDR_ERR_SUCCESS;
22607 }
22608
22609 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22610 {
22611         uint32_t cntr_info_2;
22612         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22613         ndr->depth++;
22614         if (flags & NDR_SET_VALUES) {
22615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22616         }
22617         if (flags & NDR_IN) {
22618                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22619                 ndr->depth++;
22620                 ndr_print_ptr(ndr, "servername", r->in.servername);
22621                 ndr->depth++;
22622                 if (r->in.servername) {
22623                         ndr_print_string(ndr, "servername", r->in.servername);
22624                 }
22625                 ndr->depth--;
22626                 ndr_print_ptr(ndr, "environment", r->in.environment);
22627                 ndr->depth++;
22628                 if (r->in.environment) {
22629                         ndr_print_string(ndr, "environment", r->in.environment);
22630                 }
22631                 ndr->depth--;
22632                 ndr_print_uint32(ndr, "level", r->in.level);
22633                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22634                 ndr->depth++;
22635                 if (r->in.buffer) {
22636                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22637                 }
22638                 ndr->depth--;
22639                 ndr_print_uint32(ndr, "offered", r->in.offered);
22640                 ndr->depth--;
22641         }
22642         if (flags & NDR_OUT) {
22643                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22644                 ndr->depth++;
22645                 ndr_print_ptr(ndr, "count", r->out.count);
22646                 ndr->depth++;
22647                 ndr_print_uint32(ndr, "count", *r->out.count);
22648                 ndr->depth--;
22649                 ndr_print_ptr(ndr, "info", r->out.info);
22650                 ndr->depth++;
22651                 ndr_print_ptr(ndr, "info", *r->out.info);
22652                 ndr->depth++;
22653                 if (*r->out.info) {
22654                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22655                         ndr->depth++;
22656                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22657                                 char *idx_2=NULL;
22658                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22659                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22660                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22661                                         free(idx_2);
22662                                 }
22663                         }
22664                         ndr->depth--;
22665                 }
22666                 ndr->depth--;
22667                 ndr->depth--;
22668                 ndr_print_ptr(ndr, "needed", r->out.needed);
22669                 ndr->depth++;
22670                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22671                 ndr->depth--;
22672                 ndr_print_WERROR(ndr, "result", r->out.result);
22673                 ndr->depth--;
22674         }
22675         ndr->depth--;
22676 }
22677
22678 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22679 {
22680         if (flags & NDR_IN) {
22681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22682                 if (r->in.server) {
22683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22686                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22687                 }
22688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22689                 if (r->in.environment) {
22690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22693                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22694                 }
22695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22697                 if (r->in.buffer) {
22698                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22699                 }
22700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22701         }
22702         if (flags & NDR_OUT) {
22703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22704                 if (r->out.info) {
22705                         {
22706                                 struct ndr_push *_ndr_info;
22707                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22708                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22709                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22710                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22711                         }
22712                 }
22713                 if (r->out.needed == NULL) {
22714                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22715                 }
22716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22718         }
22719         return NDR_ERR_SUCCESS;
22720 }
22721
22722 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22723 {
22724         uint32_t _ptr_server;
22725         uint32_t _ptr_environment;
22726         uint32_t _ptr_buffer;
22727         uint32_t _ptr_info;
22728         TALLOC_CTX *_mem_save_server_0;
22729         TALLOC_CTX *_mem_save_environment_0;
22730         TALLOC_CTX *_mem_save_buffer_0;
22731         TALLOC_CTX *_mem_save_info_0;
22732         TALLOC_CTX *_mem_save_needed_0;
22733         if (flags & NDR_IN) {
22734                 ZERO_STRUCT(r->out);
22735
22736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22737                 if (_ptr_server) {
22738                         NDR_PULL_ALLOC(ndr, r->in.server);
22739                 } else {
22740                         r->in.server = NULL;
22741                 }
22742                 if (r->in.server) {
22743                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22747                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22748                                 return 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));
22749                         }
22750                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22753                 }
22754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22755                 if (_ptr_environment) {
22756                         NDR_PULL_ALLOC(ndr, r->in.environment);
22757                 } else {
22758                         r->in.environment = NULL;
22759                 }
22760                 if (r->in.environment) {
22761                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22762                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22764                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22765                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22766                                 return 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));
22767                         }
22768                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22769                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22771                 }
22772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22773                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22774                 if (_ptr_buffer) {
22775                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22776                 } else {
22777                         r->in.buffer = NULL;
22778                 }
22779                 if (r->in.buffer) {
22780                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22781                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22782                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22784                 }
22785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22786                 NDR_PULL_ALLOC(ndr, r->out.needed);
22787                 ZERO_STRUCTP(r->out.needed);
22788         }
22789         if (flags & NDR_OUT) {
22790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22791                 if (_ptr_info) {
22792                         NDR_PULL_ALLOC(ndr, r->out.info);
22793                 } else {
22794                         r->out.info = NULL;
22795                 }
22796                 if (r->out.info) {
22797                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22798                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22799                         {
22800                                 struct ndr_pull *_ndr_info;
22801                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22802                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22803                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22804                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22805                         }
22806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22807                 }
22808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22809                         NDR_PULL_ALLOC(ndr, r->out.needed);
22810                 }
22811                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22812                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22815                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22816         }
22817         return NDR_ERR_SUCCESS;
22818 }
22819
22820 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22821 {
22822         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22823         ndr->depth++;
22824         if (flags & NDR_SET_VALUES) {
22825                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22826         }
22827         if (flags & NDR_IN) {
22828                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22829                 ndr->depth++;
22830                 ndr_print_ptr(ndr, "server", r->in.server);
22831                 ndr->depth++;
22832                 if (r->in.server) {
22833                         ndr_print_string(ndr, "server", r->in.server);
22834                 }
22835                 ndr->depth--;
22836                 ndr_print_ptr(ndr, "environment", r->in.environment);
22837                 ndr->depth++;
22838                 if (r->in.environment) {
22839                         ndr_print_string(ndr, "environment", r->in.environment);
22840                 }
22841                 ndr->depth--;
22842                 ndr_print_uint32(ndr, "level", r->in.level);
22843                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22844                 ndr->depth++;
22845                 if (r->in.buffer) {
22846                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22847                 }
22848                 ndr->depth--;
22849                 ndr_print_uint32(ndr, "offered", r->in.offered);
22850                 ndr->depth--;
22851         }
22852         if (flags & NDR_OUT) {
22853                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22854                 ndr->depth++;
22855                 ndr_print_ptr(ndr, "info", r->out.info);
22856                 ndr->depth++;
22857                 if (r->out.info) {
22858                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22859                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22860                 }
22861                 ndr->depth--;
22862                 ndr_print_ptr(ndr, "needed", r->out.needed);
22863                 ndr->depth++;
22864                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22865                 ndr->depth--;
22866                 ndr_print_WERROR(ndr, "result", r->out.result);
22867                 ndr->depth--;
22868         }
22869         ndr->depth--;
22870 }
22871
22872 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22873 {
22874         if (flags & NDR_IN) {
22875                 if (r->in.handle == NULL) {
22876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22877                 }
22878                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22880                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22881                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22882         }
22883         if (flags & NDR_OUT) {
22884                 if (r->out.job_id == NULL) {
22885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22886                 }
22887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22888                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22889         }
22890         return NDR_ERR_SUCCESS;
22891 }
22892
22893 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22894 {
22895         TALLOC_CTX *_mem_save_handle_0;
22896         TALLOC_CTX *_mem_save_job_id_0;
22897         if (flags & NDR_IN) {
22898                 ZERO_STRUCT(r->out);
22899
22900                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22901                         NDR_PULL_ALLOC(ndr, r->in.handle);
22902                 }
22903                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22904                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22905                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22908                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22909                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22910                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22911                 ZERO_STRUCTP(r->out.job_id);
22912         }
22913         if (flags & NDR_OUT) {
22914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22915                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22916                 }
22917                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22921                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22922         }
22923         return NDR_ERR_SUCCESS;
22924 }
22925
22926 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22927 {
22928         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22929         ndr->depth++;
22930         if (flags & NDR_SET_VALUES) {
22931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22932         }
22933         if (flags & NDR_IN) {
22934                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22935                 ndr->depth++;
22936                 ndr_print_ptr(ndr, "handle", r->in.handle);
22937                 ndr->depth++;
22938                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22939                 ndr->depth--;
22940                 ndr_print_uint32(ndr, "level", r->in.level);
22941                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22942                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22943                 ndr->depth--;
22944         }
22945         if (flags & NDR_OUT) {
22946                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22947                 ndr->depth++;
22948                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22949                 ndr->depth++;
22950                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22951                 ndr->depth--;
22952                 ndr_print_WERROR(ndr, "result", r->out.result);
22953                 ndr->depth--;
22954         }
22955         ndr->depth--;
22956 }
22957
22958 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22959 {
22960         if (flags & NDR_IN) {
22961                 if (r->in.handle == NULL) {
22962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22963                 }
22964                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22965         }
22966         if (flags & NDR_OUT) {
22967                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22968         }
22969         return NDR_ERR_SUCCESS;
22970 }
22971
22972 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22973 {
22974         TALLOC_CTX *_mem_save_handle_0;
22975         if (flags & NDR_IN) {
22976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22977                         NDR_PULL_ALLOC(ndr, r->in.handle);
22978                 }
22979                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22980                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22981                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22982                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22983         }
22984         if (flags & NDR_OUT) {
22985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22986         }
22987         return NDR_ERR_SUCCESS;
22988 }
22989
22990 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22991 {
22992         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22993         ndr->depth++;
22994         if (flags & NDR_SET_VALUES) {
22995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22996         }
22997         if (flags & NDR_IN) {
22998                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
22999                 ndr->depth++;
23000                 ndr_print_ptr(ndr, "handle", r->in.handle);
23001                 ndr->depth++;
23002                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23003                 ndr->depth--;
23004                 ndr->depth--;
23005         }
23006         if (flags & NDR_OUT) {
23007                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23008                 ndr->depth++;
23009                 ndr_print_WERROR(ndr, "result", r->out.result);
23010                 ndr->depth--;
23011         }
23012         ndr->depth--;
23013 }
23014
23015 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23016 {
23017         if (flags & NDR_IN) {
23018                 if (r->in.handle == NULL) {
23019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23020                 }
23021                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23022                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23024         }
23025         if (flags & NDR_OUT) {
23026                 if (r->out.num_written == NULL) {
23027                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23028                 }
23029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23030                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23031         }
23032         return NDR_ERR_SUCCESS;
23033 }
23034
23035 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23036 {
23037         TALLOC_CTX *_mem_save_handle_0;
23038         TALLOC_CTX *_mem_save_num_written_0;
23039         if (flags & NDR_IN) {
23040                 ZERO_STRUCT(r->out);
23041
23042                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23043                         NDR_PULL_ALLOC(ndr, r->in.handle);
23044                 }
23045                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23046                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23047                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23048                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23049                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23051                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23052                 ZERO_STRUCTP(r->out.num_written);
23053         }
23054         if (flags & NDR_OUT) {
23055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23056                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23057                 }
23058                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23063         }
23064         return NDR_ERR_SUCCESS;
23065 }
23066
23067 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23068 {
23069         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23070         ndr->depth++;
23071         if (flags & NDR_SET_VALUES) {
23072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23073         }
23074         if (flags & NDR_IN) {
23075                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23076                 ndr->depth++;
23077                 ndr_print_ptr(ndr, "handle", r->in.handle);
23078                 ndr->depth++;
23079                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23080                 ndr->depth--;
23081                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23082                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23083                 ndr->depth--;
23084         }
23085         if (flags & NDR_OUT) {
23086                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23087                 ndr->depth++;
23088                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23089                 ndr->depth++;
23090                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23091                 ndr->depth--;
23092                 ndr_print_WERROR(ndr, "result", r->out.result);
23093                 ndr->depth--;
23094         }
23095         ndr->depth--;
23096 }
23097
23098 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23099 {
23100         if (flags & NDR_IN) {
23101                 if (r->in.handle == NULL) {
23102                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23103                 }
23104                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23105         }
23106         if (flags & NDR_OUT) {
23107                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23108         }
23109         return NDR_ERR_SUCCESS;
23110 }
23111
23112 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23113 {
23114         TALLOC_CTX *_mem_save_handle_0;
23115         if (flags & NDR_IN) {
23116                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23117                         NDR_PULL_ALLOC(ndr, r->in.handle);
23118                 }
23119                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23120                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23121                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23122                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23123         }
23124         if (flags & NDR_OUT) {
23125                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23126         }
23127         return NDR_ERR_SUCCESS;
23128 }
23129
23130 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23131 {
23132         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23133         ndr->depth++;
23134         if (flags & NDR_SET_VALUES) {
23135                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23136         }
23137         if (flags & NDR_IN) {
23138                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23139                 ndr->depth++;
23140                 ndr_print_ptr(ndr, "handle", r->in.handle);
23141                 ndr->depth++;
23142                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23143                 ndr->depth--;
23144                 ndr->depth--;
23145         }
23146         if (flags & NDR_OUT) {
23147                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23148                 ndr->depth++;
23149                 ndr_print_WERROR(ndr, "result", r->out.result);
23150                 ndr->depth--;
23151         }
23152         ndr->depth--;
23153 }
23154
23155 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23156 {
23157         if (flags & NDR_IN) {
23158                 if (r->in.handle == NULL) {
23159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23160                 }
23161                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23162         }
23163         if (flags & NDR_OUT) {
23164                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23165         }
23166         return NDR_ERR_SUCCESS;
23167 }
23168
23169 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23170 {
23171         TALLOC_CTX *_mem_save_handle_0;
23172         if (flags & NDR_IN) {
23173                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23174                         NDR_PULL_ALLOC(ndr, r->in.handle);
23175                 }
23176                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23177                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23178                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23179                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23180         }
23181         if (flags & NDR_OUT) {
23182                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23183         }
23184         return NDR_ERR_SUCCESS;
23185 }
23186
23187 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23188 {
23189         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23190         ndr->depth++;
23191         if (flags & NDR_SET_VALUES) {
23192                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23193         }
23194         if (flags & NDR_IN) {
23195                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23196                 ndr->depth++;
23197                 ndr_print_ptr(ndr, "handle", r->in.handle);
23198                 ndr->depth++;
23199                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23200                 ndr->depth--;
23201                 ndr->depth--;
23202         }
23203         if (flags & NDR_OUT) {
23204                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23205                 ndr->depth++;
23206                 ndr_print_WERROR(ndr, "result", r->out.result);
23207                 ndr->depth--;
23208         }
23209         ndr->depth--;
23210 }
23211
23212 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23213 {
23214         if (flags & NDR_IN) {
23215                 if (r->in.handle == NULL) {
23216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23217                 }
23218                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23220         }
23221         if (flags & NDR_OUT) {
23222                 if (r->out.data == NULL) {
23223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23224                 }
23225                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23226                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23227                 if (r->out._data_size == NULL) {
23228                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23229                 }
23230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23232         }
23233         return NDR_ERR_SUCCESS;
23234 }
23235
23236 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23237 {
23238         TALLOC_CTX *_mem_save_handle_0;
23239         TALLOC_CTX *_mem_save__data_size_0;
23240         if (flags & NDR_IN) {
23241                 ZERO_STRUCT(r->out);
23242
23243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23244                         NDR_PULL_ALLOC(ndr, r->in.handle);
23245                 }
23246                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23247                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23248                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23251                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23252                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23253                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23254                 ZERO_STRUCTP(r->out._data_size);
23255         }
23256         if (flags & NDR_OUT) {
23257                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23258                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23259                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23260                 }
23261                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23263                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23264                 }
23265                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23266                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23269                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23270                 if (r->out.data) {
23271                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23272                 }
23273         }
23274         return NDR_ERR_SUCCESS;
23275 }
23276
23277 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23278 {
23279         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23280         ndr->depth++;
23281         if (flags & NDR_SET_VALUES) {
23282                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23283         }
23284         if (flags & NDR_IN) {
23285                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23286                 ndr->depth++;
23287                 ndr_print_ptr(ndr, "handle", r->in.handle);
23288                 ndr->depth++;
23289                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23290                 ndr->depth--;
23291                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23292                 ndr->depth--;
23293         }
23294         if (flags & NDR_OUT) {
23295                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23296                 ndr->depth++;
23297                 ndr_print_ptr(ndr, "data", r->out.data);
23298                 ndr->depth++;
23299                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23300                 ndr->depth--;
23301                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23302                 ndr->depth++;
23303                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23304                 ndr->depth--;
23305                 ndr_print_WERROR(ndr, "result", r->out.result);
23306                 ndr->depth--;
23307         }
23308         ndr->depth--;
23309 }
23310
23311 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23312 {
23313         if (flags & NDR_IN) {
23314                 if (r->in.handle == NULL) {
23315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23316                 }
23317                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23318         }
23319         if (flags & NDR_OUT) {
23320                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23321         }
23322         return NDR_ERR_SUCCESS;
23323 }
23324
23325 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23326 {
23327         TALLOC_CTX *_mem_save_handle_0;
23328         if (flags & NDR_IN) {
23329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23330                         NDR_PULL_ALLOC(ndr, r->in.handle);
23331                 }
23332                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23333                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23334                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23336         }
23337         if (flags & NDR_OUT) {
23338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23339         }
23340         return NDR_ERR_SUCCESS;
23341 }
23342
23343 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23344 {
23345         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23346         ndr->depth++;
23347         if (flags & NDR_SET_VALUES) {
23348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23349         }
23350         if (flags & NDR_IN) {
23351                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23352                 ndr->depth++;
23353                 ndr_print_ptr(ndr, "handle", r->in.handle);
23354                 ndr->depth++;
23355                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23356                 ndr->depth--;
23357                 ndr->depth--;
23358         }
23359         if (flags & NDR_OUT) {
23360                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23361                 ndr->depth++;
23362                 ndr_print_WERROR(ndr, "result", r->out.result);
23363                 ndr->depth--;
23364         }
23365         ndr->depth--;
23366 }
23367
23368 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23369 {
23370         if (flags & NDR_IN) {
23371                 if (r->in.handle == NULL) {
23372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23373                 }
23374                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23377                 if (r->in.buffer) {
23378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23379                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23380                 }
23381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23382         }
23383         if (flags & NDR_OUT) {
23384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23385                 if (r->out.buffer) {
23386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23387                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23388                 }
23389                 if (r->out.needed == NULL) {
23390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23391                 }
23392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23393                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23394         }
23395         return NDR_ERR_SUCCESS;
23396 }
23397
23398 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23399 {
23400         uint32_t _ptr_buffer;
23401         TALLOC_CTX *_mem_save_handle_0;
23402         TALLOC_CTX *_mem_save_buffer_0;
23403         TALLOC_CTX *_mem_save_needed_0;
23404         if (flags & NDR_IN) {
23405                 ZERO_STRUCT(r->out);
23406
23407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23408                         NDR_PULL_ALLOC(ndr, r->in.handle);
23409                 }
23410                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23412                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23416                 if (_ptr_buffer) {
23417                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23418                 } else {
23419                         r->in.buffer = NULL;
23420                 }
23421                 if (r->in.buffer) {
23422                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23423                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23425                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23426                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23428                 }
23429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23430                 NDR_PULL_ALLOC(ndr, r->out.needed);
23431                 ZERO_STRUCTP(r->out.needed);
23432                 if (r->in.buffer) {
23433                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23434                 }
23435         }
23436         if (flags & NDR_OUT) {
23437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23438                 if (_ptr_buffer) {
23439                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23440                 } else {
23441                         r->out.buffer = NULL;
23442                 }
23443                 if (r->out.buffer) {
23444                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23445                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23446                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23447                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23448                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23450                 }
23451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23452                         NDR_PULL_ALLOC(ndr, r->out.needed);
23453                 }
23454                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23459                 if (r->out.buffer) {
23460                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23461                 }
23462         }
23463         return NDR_ERR_SUCCESS;
23464 }
23465
23466 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23467 {
23468         ndr_print_struct(ndr, name, "spoolss_AddJob");
23469         ndr->depth++;
23470         if (flags & NDR_SET_VALUES) {
23471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23472         }
23473         if (flags & NDR_IN) {
23474                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23475                 ndr->depth++;
23476                 ndr_print_ptr(ndr, "handle", r->in.handle);
23477                 ndr->depth++;
23478                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23479                 ndr->depth--;
23480                 ndr_print_uint32(ndr, "level", r->in.level);
23481                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23482                 ndr->depth++;
23483                 if (r->in.buffer) {
23484                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23485                 }
23486                 ndr->depth--;
23487                 ndr_print_uint32(ndr, "offered", r->in.offered);
23488                 ndr->depth--;
23489         }
23490         if (flags & NDR_OUT) {
23491                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23492                 ndr->depth++;
23493                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23494                 ndr->depth++;
23495                 if (r->out.buffer) {
23496                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23497                 }
23498                 ndr->depth--;
23499                 ndr_print_ptr(ndr, "needed", r->out.needed);
23500                 ndr->depth++;
23501                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23502                 ndr->depth--;
23503                 ndr_print_WERROR(ndr, "result", r->out.result);
23504                 ndr->depth--;
23505         }
23506         ndr->depth--;
23507 }
23508
23509 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23510 {
23511         if (flags & NDR_IN) {
23512                 if (r->in.handle == NULL) {
23513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23514                 }
23515                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23517         }
23518         if (flags & NDR_OUT) {
23519                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23520         }
23521         return NDR_ERR_SUCCESS;
23522 }
23523
23524 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23525 {
23526         TALLOC_CTX *_mem_save_handle_0;
23527         if (flags & NDR_IN) {
23528                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23529                         NDR_PULL_ALLOC(ndr, r->in.handle);
23530                 }
23531                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23532                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23533                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23536         }
23537         if (flags & NDR_OUT) {
23538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23539         }
23540         return NDR_ERR_SUCCESS;
23541 }
23542
23543 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23544 {
23545         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23546         ndr->depth++;
23547         if (flags & NDR_SET_VALUES) {
23548                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23549         }
23550         if (flags & NDR_IN) {
23551                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23552                 ndr->depth++;
23553                 ndr_print_ptr(ndr, "handle", r->in.handle);
23554                 ndr->depth++;
23555                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23556                 ndr->depth--;
23557                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23558                 ndr->depth--;
23559         }
23560         if (flags & NDR_OUT) {
23561                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23562                 ndr->depth++;
23563                 ndr_print_WERROR(ndr, "result", r->out.result);
23564                 ndr->depth--;
23565         }
23566         ndr->depth--;
23567 }
23568
23569 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23570 {
23571         if (flags & NDR_IN) {
23572                 if (r->in.handle == NULL) {
23573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23574                 }
23575                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23576                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23577                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23578                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23579                 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));
23580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23581         }
23582         if (flags & NDR_OUT) {
23583                 if (r->out.type == NULL) {
23584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23585                 }
23586                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23587                 if (r->out.data == NULL) {
23588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23589                 }
23590                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23591                 if (r->out.needed == NULL) {
23592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23593                 }
23594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23595                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23596         }
23597         return NDR_ERR_SUCCESS;
23598 }
23599
23600 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23601 {
23602         TALLOC_CTX *_mem_save_handle_0;
23603         TALLOC_CTX *_mem_save_type_0;
23604         TALLOC_CTX *_mem_save_data_0;
23605         TALLOC_CTX *_mem_save_needed_0;
23606         if (flags & NDR_IN) {
23607                 ZERO_STRUCT(r->out);
23608
23609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23610                         NDR_PULL_ALLOC(ndr, r->in.handle);
23611                 }
23612                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23613                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23614                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23616                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23617                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23618                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23619                         return 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));
23620                 }
23621                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23622                 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));
23623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23624                 NDR_PULL_ALLOC(ndr, r->out.type);
23625                 ZERO_STRUCTP(r->out.type);
23626                 NDR_PULL_ALLOC(ndr, r->out.data);
23627                 ZERO_STRUCTP(r->out.data);
23628                 NDR_PULL_ALLOC(ndr, r->out.needed);
23629                 ZERO_STRUCTP(r->out.needed);
23630         }
23631         if (flags & NDR_OUT) {
23632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23633                         NDR_PULL_ALLOC(ndr, r->out.type);
23634                 }
23635                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23636                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23637                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23639                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23640                         NDR_PULL_ALLOC(ndr, r->out.data);
23641                 }
23642                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23643                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23644                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23645                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23647                         NDR_PULL_ALLOC(ndr, r->out.needed);
23648                 }
23649                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23650                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23653                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23654         }
23655         return NDR_ERR_SUCCESS;
23656 }
23657
23658 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23659 {
23660         if (flags & NDR_IN) {
23661                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23662         }
23663         if (flags & NDR_OUT) {
23664                 if (r->out.data == NULL) {
23665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23666                 }
23667                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23668                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23669         }
23670         return NDR_ERR_SUCCESS;
23671 }
23672
23673 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23674 {
23675         TALLOC_CTX *_mem_save_data_0;
23676         if (flags & NDR_IN) {
23677                 ZERO_STRUCT(r->out);
23678
23679                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23680                 NDR_PULL_ALLOC(ndr, r->out.data);
23681                 ZERO_STRUCTP(r->out.data);
23682         }
23683         if (flags & NDR_OUT) {
23684                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23685                         NDR_PULL_ALLOC(ndr, r->out.data);
23686                 }
23687                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23688                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23689                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23690                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23692         }
23693         return NDR_ERR_SUCCESS;
23694 }
23695
23696 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23697 {
23698         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23699         ndr->depth++;
23700         if (flags & NDR_SET_VALUES) {
23701                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23702         }
23703         if (flags & NDR_IN) {
23704                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23705                 ndr->depth++;
23706                 ndr_print_ptr(ndr, "handle", r->in.handle);
23707                 ndr->depth++;
23708                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23709                 ndr->depth--;
23710                 ndr_print_string(ndr, "value_name", r->in.value_name);
23711                 ndr_print_uint32(ndr, "offered", r->in.offered);
23712                 ndr->depth--;
23713         }
23714         if (flags & NDR_OUT) {
23715                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23716                 ndr->depth++;
23717                 ndr_print_ptr(ndr, "type", r->out.type);
23718                 ndr->depth++;
23719                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23720                 ndr->depth--;
23721                 ndr_print_ptr(ndr, "data", r->out.data);
23722                 ndr->depth++;
23723                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23724                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23725                 ndr->depth--;
23726                 ndr_print_ptr(ndr, "needed", r->out.needed);
23727                 ndr->depth++;
23728                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23729                 ndr->depth--;
23730                 ndr_print_WERROR(ndr, "result", r->out.result);
23731                 ndr->depth--;
23732         }
23733         ndr->depth--;
23734 }
23735
23736 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23737 {
23738         if (flags & NDR_IN) {
23739                 if (r->in.handle == NULL) {
23740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23741                 }
23742                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23743                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23744                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23745                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23746                 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));
23747                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23748                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23750         }
23751         if (flags & NDR_OUT) {
23752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23753         }
23754         return NDR_ERR_SUCCESS;
23755 }
23756
23757 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23758 {
23759         if (flags & NDR_IN) {
23760                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23761         }
23762         if (flags & NDR_OUT) {
23763                 if (r->out.data == NULL) {
23764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23765                 }
23766                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23767                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23768         }
23769         return NDR_ERR_SUCCESS;
23770 }
23771
23772 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23773 {
23774         TALLOC_CTX *_mem_save_handle_0;
23775         if (flags & NDR_IN) {
23776                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23777                         NDR_PULL_ALLOC(ndr, r->in.handle);
23778                 }
23779                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23780                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23781                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23782                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23783                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23784                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23785                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23786                         return 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));
23787                 }
23788                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23789                 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));
23790                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23791                 {
23792                         struct ndr_pull *_ndr_data;
23793                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23794                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23795                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23796                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23797                 }
23798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23799         }
23800         if (flags & NDR_OUT) {
23801                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23802         }
23803         return NDR_ERR_SUCCESS;
23804 }
23805
23806 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23807 {
23808         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23809         ndr->depth++;
23810         if (flags & NDR_SET_VALUES) {
23811                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23812         }
23813         if (flags & NDR_IN) {
23814                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23815                 ndr->depth++;
23816                 ndr_print_ptr(ndr, "handle", r->in.handle);
23817                 ndr->depth++;
23818                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23819                 ndr->depth--;
23820                 ndr_print_string(ndr, "value_name", r->in.value_name);
23821                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23822                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23823                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23824                 ndr_print_uint32(ndr, "_offered", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(&r->in.data, r->in.type, ndr->iconv_convenience, flags):r->in._offered);
23825                 ndr->depth--;
23826         }
23827         if (flags & NDR_OUT) {
23828                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23829                 ndr->depth++;
23830                 ndr_print_WERROR(ndr, "result", r->out.result);
23831                 ndr->depth--;
23832         }
23833         ndr->depth--;
23834 }
23835
23836 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23837 {
23838         if (flags & NDR_IN) {
23839         }
23840         if (flags & NDR_OUT) {
23841                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23842         }
23843         return NDR_ERR_SUCCESS;
23844 }
23845
23846 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23847 {
23848         if (flags & NDR_IN) {
23849         }
23850         if (flags & NDR_OUT) {
23851                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23852         }
23853         return NDR_ERR_SUCCESS;
23854 }
23855
23856 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23857 {
23858         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23859         ndr->depth++;
23860         if (flags & NDR_SET_VALUES) {
23861                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23862         }
23863         if (flags & NDR_IN) {
23864                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23865                 ndr->depth++;
23866                 ndr->depth--;
23867         }
23868         if (flags & NDR_OUT) {
23869                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23870                 ndr->depth++;
23871                 ndr_print_WERROR(ndr, "result", r->out.result);
23872                 ndr->depth--;
23873         }
23874         ndr->depth--;
23875 }
23876
23877 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23878 {
23879         if (flags & NDR_IN) {
23880                 if (r->in.handle == NULL) {
23881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23882                 }
23883                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23884         }
23885         if (flags & NDR_OUT) {
23886                 if (r->out.handle == NULL) {
23887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23888                 }
23889                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23891         }
23892         return NDR_ERR_SUCCESS;
23893 }
23894
23895 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23896 {
23897         TALLOC_CTX *_mem_save_handle_0;
23898         if (flags & NDR_IN) {
23899                 ZERO_STRUCT(r->out);
23900
23901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23902                         NDR_PULL_ALLOC(ndr, r->in.handle);
23903                 }
23904                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23905                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23906                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23908                 NDR_PULL_ALLOC(ndr, r->out.handle);
23909                 *r->out.handle = *r->in.handle;
23910         }
23911         if (flags & NDR_OUT) {
23912                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23913                         NDR_PULL_ALLOC(ndr, r->out.handle);
23914                 }
23915                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23916                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23917                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23918                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23919                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23920         }
23921         return NDR_ERR_SUCCESS;
23922 }
23923
23924 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23925 {
23926         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23927         ndr->depth++;
23928         if (flags & NDR_SET_VALUES) {
23929                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23930         }
23931         if (flags & NDR_IN) {
23932                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23933                 ndr->depth++;
23934                 ndr_print_ptr(ndr, "handle", r->in.handle);
23935                 ndr->depth++;
23936                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23937                 ndr->depth--;
23938                 ndr->depth--;
23939         }
23940         if (flags & NDR_OUT) {
23941                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23942                 ndr->depth++;
23943                 ndr_print_ptr(ndr, "handle", r->out.handle);
23944                 ndr->depth++;
23945                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23946                 ndr->depth--;
23947                 ndr_print_WERROR(ndr, "result", r->out.result);
23948                 ndr->depth--;
23949         }
23950         ndr->depth--;
23951 }
23952
23953 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23954 {
23955         if (flags & NDR_IN) {
23956                 if (r->in.handle == NULL) {
23957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23958                 }
23959                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23961                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23962                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23963         }
23964         if (flags & NDR_OUT) {
23965                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23966         }
23967         return NDR_ERR_SUCCESS;
23968 }
23969
23970 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23971 {
23972         TALLOC_CTX *_mem_save_handle_0;
23973         if (flags & NDR_IN) {
23974                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23975                         NDR_PULL_ALLOC(ndr, r->in.handle);
23976                 }
23977                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23978                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23979                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23982                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23983                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23984         }
23985         if (flags & NDR_OUT) {
23986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23987         }
23988         return NDR_ERR_SUCCESS;
23989 }
23990
23991 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23992 {
23993         ndr_print_struct(ndr, name, "spoolss_AddForm");
23994         ndr->depth++;
23995         if (flags & NDR_SET_VALUES) {
23996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23997         }
23998         if (flags & NDR_IN) {
23999                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24000                 ndr->depth++;
24001                 ndr_print_ptr(ndr, "handle", r->in.handle);
24002                 ndr->depth++;
24003                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24004                 ndr->depth--;
24005                 ndr_print_uint32(ndr, "level", r->in.level);
24006                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24007                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24008                 ndr->depth--;
24009         }
24010         if (flags & NDR_OUT) {
24011                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24012                 ndr->depth++;
24013                 ndr_print_WERROR(ndr, "result", r->out.result);
24014                 ndr->depth--;
24015         }
24016         ndr->depth--;
24017 }
24018
24019 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24020 {
24021         if (flags & NDR_IN) {
24022                 if (r->in.handle == NULL) {
24023                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24024                 }
24025                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24026                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24027                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24028                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24029                 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));
24030         }
24031         if (flags & NDR_OUT) {
24032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24033         }
24034         return NDR_ERR_SUCCESS;
24035 }
24036
24037 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24038 {
24039         TALLOC_CTX *_mem_save_handle_0;
24040         if (flags & NDR_IN) {
24041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24042                         NDR_PULL_ALLOC(ndr, r->in.handle);
24043                 }
24044                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24045                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24046                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24048                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24049                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24050                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24051                         return 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));
24052                 }
24053                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24054                 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));
24055         }
24056         if (flags & NDR_OUT) {
24057                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24058         }
24059         return NDR_ERR_SUCCESS;
24060 }
24061
24062 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24063 {
24064         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24065         ndr->depth++;
24066         if (flags & NDR_SET_VALUES) {
24067                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24068         }
24069         if (flags & NDR_IN) {
24070                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24071                 ndr->depth++;
24072                 ndr_print_ptr(ndr, "handle", r->in.handle);
24073                 ndr->depth++;
24074                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24075                 ndr->depth--;
24076                 ndr_print_string(ndr, "form_name", r->in.form_name);
24077                 ndr->depth--;
24078         }
24079         if (flags & NDR_OUT) {
24080                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24081                 ndr->depth++;
24082                 ndr_print_WERROR(ndr, "result", r->out.result);
24083                 ndr->depth--;
24084         }
24085         ndr->depth--;
24086 }
24087
24088 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24089 {
24090         if (flags & NDR_IN) {
24091                 if (r->in.handle == NULL) {
24092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24093                 }
24094                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24095                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24096                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24098                 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));
24099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24101                 if (r->in.buffer) {
24102                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24103                 }
24104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24105         }
24106         if (flags & NDR_OUT) {
24107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24108                 if (r->out.info) {
24109                         {
24110                                 struct ndr_push *_ndr_info;
24111                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24112                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24113                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24114                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24115                         }
24116                 }
24117                 if (r->out.needed == NULL) {
24118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24119                 }
24120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24121                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24122         }
24123         return NDR_ERR_SUCCESS;
24124 }
24125
24126 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24127 {
24128         uint32_t _ptr_buffer;
24129         uint32_t _ptr_info;
24130         TALLOC_CTX *_mem_save_handle_0;
24131         TALLOC_CTX *_mem_save_buffer_0;
24132         TALLOC_CTX *_mem_save_info_0;
24133         TALLOC_CTX *_mem_save_needed_0;
24134         if (flags & NDR_IN) {
24135                 ZERO_STRUCT(r->out);
24136
24137                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24138                         NDR_PULL_ALLOC(ndr, r->in.handle);
24139                 }
24140                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24141                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24142                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24144                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24145                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24146                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24147                         return 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));
24148                 }
24149                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24150                 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));
24151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24153                 if (_ptr_buffer) {
24154                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24155                 } else {
24156                         r->in.buffer = NULL;
24157                 }
24158                 if (r->in.buffer) {
24159                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24160                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24161                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24163                 }
24164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24165                 NDR_PULL_ALLOC(ndr, r->out.needed);
24166                 ZERO_STRUCTP(r->out.needed);
24167         }
24168         if (flags & NDR_OUT) {
24169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24170                 if (_ptr_info) {
24171                         NDR_PULL_ALLOC(ndr, r->out.info);
24172                 } else {
24173                         r->out.info = NULL;
24174                 }
24175                 if (r->out.info) {
24176                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24177                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24178                         {
24179                                 struct ndr_pull *_ndr_info;
24180                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24181                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24182                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24183                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24184                         }
24185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24186                 }
24187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24188                         NDR_PULL_ALLOC(ndr, r->out.needed);
24189                 }
24190                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24195         }
24196         return NDR_ERR_SUCCESS;
24197 }
24198
24199 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24200 {
24201         ndr_print_struct(ndr, name, "spoolss_GetForm");
24202         ndr->depth++;
24203         if (flags & NDR_SET_VALUES) {
24204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24205         }
24206         if (flags & NDR_IN) {
24207                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24208                 ndr->depth++;
24209                 ndr_print_ptr(ndr, "handle", r->in.handle);
24210                 ndr->depth++;
24211                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24212                 ndr->depth--;
24213                 ndr_print_string(ndr, "form_name", r->in.form_name);
24214                 ndr_print_uint32(ndr, "level", r->in.level);
24215                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24216                 ndr->depth++;
24217                 if (r->in.buffer) {
24218                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24219                 }
24220                 ndr->depth--;
24221                 ndr_print_uint32(ndr, "offered", r->in.offered);
24222                 ndr->depth--;
24223         }
24224         if (flags & NDR_OUT) {
24225                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24226                 ndr->depth++;
24227                 ndr_print_ptr(ndr, "info", r->out.info);
24228                 ndr->depth++;
24229                 if (r->out.info) {
24230                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24231                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24232                 }
24233                 ndr->depth--;
24234                 ndr_print_ptr(ndr, "needed", r->out.needed);
24235                 ndr->depth++;
24236                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24237                 ndr->depth--;
24238                 ndr_print_WERROR(ndr, "result", r->out.result);
24239                 ndr->depth--;
24240         }
24241         ndr->depth--;
24242 }
24243
24244 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24245 {
24246         if (flags & NDR_IN) {
24247                 if (r->in.handle == NULL) {
24248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24249                 }
24250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24251                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24252                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24253                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24254                 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));
24255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24256                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24257                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24258         }
24259         if (flags & NDR_OUT) {
24260                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24261         }
24262         return NDR_ERR_SUCCESS;
24263 }
24264
24265 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24266 {
24267         TALLOC_CTX *_mem_save_handle_0;
24268         if (flags & NDR_IN) {
24269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24270                         NDR_PULL_ALLOC(ndr, r->in.handle);
24271                 }
24272                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24273                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24274                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24276                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24277                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24278                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24279                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.form_name), ndr_get_array_length(ndr, &r->in.form_name));
24280                 }
24281                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24282                 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));
24283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24284                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24285                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24286         }
24287         if (flags & NDR_OUT) {
24288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24289         }
24290         return NDR_ERR_SUCCESS;
24291 }
24292
24293 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24294 {
24295         ndr_print_struct(ndr, name, "spoolss_SetForm");
24296         ndr->depth++;
24297         if (flags & NDR_SET_VALUES) {
24298                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24299         }
24300         if (flags & NDR_IN) {
24301                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24302                 ndr->depth++;
24303                 ndr_print_ptr(ndr, "handle", r->in.handle);
24304                 ndr->depth++;
24305                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24306                 ndr->depth--;
24307                 ndr_print_string(ndr, "form_name", r->in.form_name);
24308                 ndr_print_uint32(ndr, "level", r->in.level);
24309                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24310                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24311                 ndr->depth--;
24312         }
24313         if (flags & NDR_OUT) {
24314                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24315                 ndr->depth++;
24316                 ndr_print_WERROR(ndr, "result", r->out.result);
24317                 ndr->depth--;
24318         }
24319         ndr->depth--;
24320 }
24321
24322 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24323 {
24324         if (flags & NDR_IN) {
24325                 if (r->in.handle == NULL) {
24326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24327                 }
24328                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24330                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24331                 if (r->in.buffer) {
24332                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24333                 }
24334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24335         }
24336         if (flags & NDR_OUT) {
24337                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24338                 if (r->out.info) {
24339                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24340                 }
24341                 if (r->out.needed == NULL) {
24342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24343                 }
24344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24345                 if (r->out.count == NULL) {
24346                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24347                 }
24348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24350         }
24351         return NDR_ERR_SUCCESS;
24352 }
24353
24354 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24355 {
24356         uint32_t _ptr_buffer;
24357         uint32_t _ptr_info;
24358         TALLOC_CTX *_mem_save_handle_0;
24359         TALLOC_CTX *_mem_save_buffer_0;
24360         TALLOC_CTX *_mem_save_info_0;
24361         TALLOC_CTX *_mem_save_needed_0;
24362         TALLOC_CTX *_mem_save_count_0;
24363         if (flags & NDR_IN) {
24364                 ZERO_STRUCT(r->out);
24365
24366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24367                         NDR_PULL_ALLOC(ndr, r->in.handle);
24368                 }
24369                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24370                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24371                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24375                 if (_ptr_buffer) {
24376                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24377                 } else {
24378                         r->in.buffer = NULL;
24379                 }
24380                 if (r->in.buffer) {
24381                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24382                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24383                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24385                 }
24386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24387                 NDR_PULL_ALLOC(ndr, r->out.needed);
24388                 ZERO_STRUCTP(r->out.needed);
24389                 NDR_PULL_ALLOC(ndr, r->out.count);
24390                 ZERO_STRUCTP(r->out.count);
24391         }
24392         if (flags & NDR_OUT) {
24393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24394                 if (_ptr_info) {
24395                         NDR_PULL_ALLOC(ndr, r->out.info);
24396                 } else {
24397                         r->out.info = NULL;
24398                 }
24399                 if (r->out.info) {
24400                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24401                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24402                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24404                 }
24405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24406                         NDR_PULL_ALLOC(ndr, r->out.needed);
24407                 }
24408                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24409                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24412                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24413                         NDR_PULL_ALLOC(ndr, r->out.count);
24414                 }
24415                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24416                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24418                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24420         }
24421         return NDR_ERR_SUCCESS;
24422 }
24423
24424 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24425 {
24426         uint32_t cntr_info_0;
24427         if (flags & NDR_IN) {
24428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24430         }
24431         if (flags & NDR_OUT) {
24432                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24433                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24434                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24435                 }
24436                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24437                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24438                 }
24439         }
24440         return NDR_ERR_SUCCESS;
24441 }
24442
24443 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24444 {
24445         uint32_t cntr_info_0;
24446         TALLOC_CTX *_mem_save_info_0;
24447         if (flags & NDR_IN) {
24448                 ZERO_STRUCT(r->out);
24449
24450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24451                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24452         }
24453         if (flags & NDR_OUT) {
24454                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24455                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24456                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24457                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24458                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24459                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24460                 }
24461                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24462                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24463                 }
24464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24465         }
24466         return NDR_ERR_SUCCESS;
24467 }
24468
24469 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24470 {
24471         uint32_t cntr_info_2;
24472         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24473         ndr->depth++;
24474         if (flags & NDR_SET_VALUES) {
24475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24476         }
24477         if (flags & NDR_IN) {
24478                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24479                 ndr->depth++;
24480                 ndr_print_ptr(ndr, "handle", r->in.handle);
24481                 ndr->depth++;
24482                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24483                 ndr->depth--;
24484                 ndr_print_uint32(ndr, "level", r->in.level);
24485                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24486                 ndr->depth++;
24487                 if (r->in.buffer) {
24488                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24489                 }
24490                 ndr->depth--;
24491                 ndr_print_uint32(ndr, "offered", r->in.offered);
24492                 ndr->depth--;
24493         }
24494         if (flags & NDR_OUT) {
24495                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24496                 ndr->depth++;
24497                 ndr_print_ptr(ndr, "count", r->out.count);
24498                 ndr->depth++;
24499                 ndr_print_uint32(ndr, "count", *r->out.count);
24500                 ndr->depth--;
24501                 ndr_print_ptr(ndr, "info", r->out.info);
24502                 ndr->depth++;
24503                 ndr_print_ptr(ndr, "info", *r->out.info);
24504                 ndr->depth++;
24505                 if (*r->out.info) {
24506                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24507                         ndr->depth++;
24508                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24509                                 char *idx_2=NULL;
24510                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24511                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24512                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24513                                         free(idx_2);
24514                                 }
24515                         }
24516                         ndr->depth--;
24517                 }
24518                 ndr->depth--;
24519                 ndr->depth--;
24520                 ndr_print_ptr(ndr, "needed", r->out.needed);
24521                 ndr->depth++;
24522                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24523                 ndr->depth--;
24524                 ndr_print_WERROR(ndr, "result", r->out.result);
24525                 ndr->depth--;
24526         }
24527         ndr->depth--;
24528 }
24529
24530 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24531 {
24532         if (flags & NDR_IN) {
24533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24534                 if (r->in.servername) {
24535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24536                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24538                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24539                 }
24540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24541                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24542                 if (r->in.buffer) {
24543                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24544                 }
24545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24546         }
24547         if (flags & NDR_OUT) {
24548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24549                 if (r->out.info) {
24550                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24551                 }
24552                 if (r->out.needed == NULL) {
24553                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24554                 }
24555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24556                 if (r->out.count == NULL) {
24557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24558                 }
24559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24560                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24561         }
24562         return NDR_ERR_SUCCESS;
24563 }
24564
24565 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24566 {
24567         uint32_t _ptr_servername;
24568         uint32_t _ptr_buffer;
24569         uint32_t _ptr_info;
24570         TALLOC_CTX *_mem_save_servername_0;
24571         TALLOC_CTX *_mem_save_buffer_0;
24572         TALLOC_CTX *_mem_save_info_0;
24573         TALLOC_CTX *_mem_save_needed_0;
24574         TALLOC_CTX *_mem_save_count_0;
24575         if (flags & NDR_IN) {
24576                 ZERO_STRUCT(r->out);
24577
24578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24579                 if (_ptr_servername) {
24580                         NDR_PULL_ALLOC(ndr, r->in.servername);
24581                 } else {
24582                         r->in.servername = NULL;
24583                 }
24584                 if (r->in.servername) {
24585                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24586                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24589                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24590                                 return 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));
24591                         }
24592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24595                 }
24596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24598                 if (_ptr_buffer) {
24599                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24600                 } else {
24601                         r->in.buffer = NULL;
24602                 }
24603                 if (r->in.buffer) {
24604                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24605                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24606                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24608                 }
24609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24610                 NDR_PULL_ALLOC(ndr, r->out.needed);
24611                 ZERO_STRUCTP(r->out.needed);
24612                 NDR_PULL_ALLOC(ndr, r->out.count);
24613                 ZERO_STRUCTP(r->out.count);
24614         }
24615         if (flags & NDR_OUT) {
24616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24617                 if (_ptr_info) {
24618                         NDR_PULL_ALLOC(ndr, r->out.info);
24619                 } else {
24620                         r->out.info = NULL;
24621                 }
24622                 if (r->out.info) {
24623                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24624                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24625                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24627                 }
24628                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24629                         NDR_PULL_ALLOC(ndr, r->out.needed);
24630                 }
24631                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24632                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24635                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24636                         NDR_PULL_ALLOC(ndr, r->out.count);
24637                 }
24638                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24639                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24642                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24643         }
24644         return NDR_ERR_SUCCESS;
24645 }
24646
24647 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24648 {
24649         uint32_t cntr_info_0;
24650         if (flags & NDR_IN) {
24651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24653         }
24654         if (flags & NDR_OUT) {
24655                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24656                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24657                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24658                 }
24659                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24660                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24661                 }
24662         }
24663         return NDR_ERR_SUCCESS;
24664 }
24665
24666 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24667 {
24668         uint32_t cntr_info_0;
24669         TALLOC_CTX *_mem_save_info_0;
24670         if (flags & NDR_IN) {
24671                 ZERO_STRUCT(r->out);
24672
24673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24675         }
24676         if (flags & NDR_OUT) {
24677                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24678                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24679                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24680                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24681                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24682                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24683                 }
24684                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24685                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24686                 }
24687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24688         }
24689         return NDR_ERR_SUCCESS;
24690 }
24691
24692 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24693 {
24694         uint32_t cntr_info_2;
24695         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24696         ndr->depth++;
24697         if (flags & NDR_SET_VALUES) {
24698                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24699         }
24700         if (flags & NDR_IN) {
24701                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24702                 ndr->depth++;
24703                 ndr_print_ptr(ndr, "servername", r->in.servername);
24704                 ndr->depth++;
24705                 if (r->in.servername) {
24706                         ndr_print_string(ndr, "servername", r->in.servername);
24707                 }
24708                 ndr->depth--;
24709                 ndr_print_uint32(ndr, "level", r->in.level);
24710                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24711                 ndr->depth++;
24712                 if (r->in.buffer) {
24713                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24714                 }
24715                 ndr->depth--;
24716                 ndr_print_uint32(ndr, "offered", r->in.offered);
24717                 ndr->depth--;
24718         }
24719         if (flags & NDR_OUT) {
24720                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24721                 ndr->depth++;
24722                 ndr_print_ptr(ndr, "count", r->out.count);
24723                 ndr->depth++;
24724                 ndr_print_uint32(ndr, "count", *r->out.count);
24725                 ndr->depth--;
24726                 ndr_print_ptr(ndr, "info", r->out.info);
24727                 ndr->depth++;
24728                 ndr_print_ptr(ndr, "info", *r->out.info);
24729                 ndr->depth++;
24730                 if (*r->out.info) {
24731                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24732                         ndr->depth++;
24733                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24734                                 char *idx_2=NULL;
24735                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24736                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24737                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24738                                         free(idx_2);
24739                                 }
24740                         }
24741                         ndr->depth--;
24742                 }
24743                 ndr->depth--;
24744                 ndr->depth--;
24745                 ndr_print_ptr(ndr, "needed", r->out.needed);
24746                 ndr->depth++;
24747                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24748                 ndr->depth--;
24749                 ndr_print_WERROR(ndr, "result", r->out.result);
24750                 ndr->depth--;
24751         }
24752         ndr->depth--;
24753 }
24754
24755 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24756 {
24757         if (flags & NDR_IN) {
24758                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24759                 if (r->in.servername) {
24760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24764                 }
24765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24767                 if (r->in.buffer) {
24768                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24769                 }
24770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24771         }
24772         if (flags & NDR_OUT) {
24773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24774                 if (r->out.info) {
24775                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24776                 }
24777                 if (r->out.needed == NULL) {
24778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24779                 }
24780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24781                 if (r->out.count == NULL) {
24782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24783                 }
24784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24786         }
24787         return NDR_ERR_SUCCESS;
24788 }
24789
24790 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24791 {
24792         uint32_t _ptr_servername;
24793         uint32_t _ptr_buffer;
24794         uint32_t _ptr_info;
24795         TALLOC_CTX *_mem_save_servername_0;
24796         TALLOC_CTX *_mem_save_buffer_0;
24797         TALLOC_CTX *_mem_save_info_0;
24798         TALLOC_CTX *_mem_save_needed_0;
24799         TALLOC_CTX *_mem_save_count_0;
24800         if (flags & NDR_IN) {
24801                 ZERO_STRUCT(r->out);
24802
24803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24804                 if (_ptr_servername) {
24805                         NDR_PULL_ALLOC(ndr, r->in.servername);
24806                 } else {
24807                         r->in.servername = NULL;
24808                 }
24809                 if (r->in.servername) {
24810                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24811                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24812                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24813                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24814                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24815                                 return 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));
24816                         }
24817                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24818                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24820                 }
24821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24823                 if (_ptr_buffer) {
24824                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24825                 } else {
24826                         r->in.buffer = NULL;
24827                 }
24828                 if (r->in.buffer) {
24829                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24830                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24831                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24832                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24833                 }
24834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24835                 NDR_PULL_ALLOC(ndr, r->out.needed);
24836                 ZERO_STRUCTP(r->out.needed);
24837                 NDR_PULL_ALLOC(ndr, r->out.count);
24838                 ZERO_STRUCTP(r->out.count);
24839         }
24840         if (flags & NDR_OUT) {
24841                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24842                 if (_ptr_info) {
24843                         NDR_PULL_ALLOC(ndr, r->out.info);
24844                 } else {
24845                         r->out.info = NULL;
24846                 }
24847                 if (r->out.info) {
24848                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24849                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24850                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24851                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24852                 }
24853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24854                         NDR_PULL_ALLOC(ndr, r->out.needed);
24855                 }
24856                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24857                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24860                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24861                         NDR_PULL_ALLOC(ndr, r->out.count);
24862                 }
24863                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24864                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24866                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24867                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24868         }
24869         return NDR_ERR_SUCCESS;
24870 }
24871
24872 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24873 {
24874         uint32_t cntr_info_0;
24875         if (flags & NDR_IN) {
24876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24878         }
24879         if (flags & NDR_OUT) {
24880                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24881                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24882                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24883                 }
24884                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24885                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24886                 }
24887         }
24888         return NDR_ERR_SUCCESS;
24889 }
24890
24891 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24892 {
24893         uint32_t cntr_info_0;
24894         TALLOC_CTX *_mem_save_info_0;
24895         if (flags & NDR_IN) {
24896                 ZERO_STRUCT(r->out);
24897
24898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24900         }
24901         if (flags & NDR_OUT) {
24902                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24903                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24904                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24905                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24906                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24907                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24908                 }
24909                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24910                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24911                 }
24912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24913         }
24914         return NDR_ERR_SUCCESS;
24915 }
24916
24917 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24918 {
24919         uint32_t cntr_info_2;
24920         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24921         ndr->depth++;
24922         if (flags & NDR_SET_VALUES) {
24923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24924         }
24925         if (flags & NDR_IN) {
24926                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24927                 ndr->depth++;
24928                 ndr_print_ptr(ndr, "servername", r->in.servername);
24929                 ndr->depth++;
24930                 if (r->in.servername) {
24931                         ndr_print_string(ndr, "servername", r->in.servername);
24932                 }
24933                 ndr->depth--;
24934                 ndr_print_uint32(ndr, "level", r->in.level);
24935                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24936                 ndr->depth++;
24937                 if (r->in.buffer) {
24938                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24939                 }
24940                 ndr->depth--;
24941                 ndr_print_uint32(ndr, "offered", r->in.offered);
24942                 ndr->depth--;
24943         }
24944         if (flags & NDR_OUT) {
24945                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24946                 ndr->depth++;
24947                 ndr_print_ptr(ndr, "count", r->out.count);
24948                 ndr->depth++;
24949                 ndr_print_uint32(ndr, "count", *r->out.count);
24950                 ndr->depth--;
24951                 ndr_print_ptr(ndr, "info", r->out.info);
24952                 ndr->depth++;
24953                 ndr_print_ptr(ndr, "info", *r->out.info);
24954                 ndr->depth++;
24955                 if (*r->out.info) {
24956                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24957                         ndr->depth++;
24958                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24959                                 char *idx_2=NULL;
24960                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24961                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24962                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24963                                         free(idx_2);
24964                                 }
24965                         }
24966                         ndr->depth--;
24967                 }
24968                 ndr->depth--;
24969                 ndr->depth--;
24970                 ndr_print_ptr(ndr, "needed", r->out.needed);
24971                 ndr->depth++;
24972                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24973                 ndr->depth--;
24974                 ndr_print_WERROR(ndr, "result", r->out.result);
24975                 ndr->depth--;
24976         }
24977         ndr->depth--;
24978 }
24979
24980 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24981 {
24982         if (flags & NDR_IN) {
24983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24984                 if (r->in.server_name) {
24985                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24986                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24988                         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));
24989                 }
24990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24991                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24992                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24993                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24994                 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));
24995         }
24996         if (flags & NDR_OUT) {
24997                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24998         }
24999         return NDR_ERR_SUCCESS;
25000 }
25001
25002 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25003 {
25004         uint32_t _ptr_server_name;
25005         TALLOC_CTX *_mem_save_server_name_0;
25006         if (flags & NDR_IN) {
25007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25008                 if (_ptr_server_name) {
25009                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25010                 } else {
25011                         r->in.server_name = NULL;
25012                 }
25013                 if (r->in.server_name) {
25014                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25015                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25018                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25019                                 return 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));
25020                         }
25021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25022                         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));
25023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25024                 }
25025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25026                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25027                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25028                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25029                         return 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));
25030                 }
25031                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25032                 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));
25033         }
25034         if (flags & NDR_OUT) {
25035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25036         }
25037         return NDR_ERR_SUCCESS;
25038 }
25039
25040 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25041 {
25042         ndr_print_struct(ndr, name, "spoolss_AddPort");
25043         ndr->depth++;
25044         if (flags & NDR_SET_VALUES) {
25045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25046         }
25047         if (flags & NDR_IN) {
25048                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25049                 ndr->depth++;
25050                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25051                 ndr->depth++;
25052                 if (r->in.server_name) {
25053                         ndr_print_string(ndr, "server_name", r->in.server_name);
25054                 }
25055                 ndr->depth--;
25056                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25057                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25058                 ndr->depth--;
25059         }
25060         if (flags & NDR_OUT) {
25061                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25062                 ndr->depth++;
25063                 ndr_print_WERROR(ndr, "result", r->out.result);
25064                 ndr->depth--;
25065         }
25066         ndr->depth--;
25067 }
25068
25069 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25070 {
25071         if (flags & NDR_IN) {
25072         }
25073         if (flags & NDR_OUT) {
25074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25075         }
25076         return NDR_ERR_SUCCESS;
25077 }
25078
25079 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25080 {
25081         if (flags & NDR_IN) {
25082         }
25083         if (flags & NDR_OUT) {
25084                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25085         }
25086         return NDR_ERR_SUCCESS;
25087 }
25088
25089 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25090 {
25091         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25092         ndr->depth++;
25093         if (flags & NDR_SET_VALUES) {
25094                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25095         }
25096         if (flags & NDR_IN) {
25097                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25098                 ndr->depth++;
25099                 ndr->depth--;
25100         }
25101         if (flags & NDR_OUT) {
25102                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25103                 ndr->depth++;
25104                 ndr_print_WERROR(ndr, "result", r->out.result);
25105                 ndr->depth--;
25106         }
25107         ndr->depth--;
25108 }
25109
25110 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25111 {
25112         if (flags & NDR_IN) {
25113         }
25114         if (flags & NDR_OUT) {
25115                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25116         }
25117         return NDR_ERR_SUCCESS;
25118 }
25119
25120 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25121 {
25122         if (flags & NDR_IN) {
25123         }
25124         if (flags & NDR_OUT) {
25125                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25126         }
25127         return NDR_ERR_SUCCESS;
25128 }
25129
25130 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25131 {
25132         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25133         ndr->depth++;
25134         if (flags & NDR_SET_VALUES) {
25135                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25136         }
25137         if (flags & NDR_IN) {
25138                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25139                 ndr->depth++;
25140                 ndr->depth--;
25141         }
25142         if (flags & NDR_OUT) {
25143                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25144                 ndr->depth++;
25145                 ndr_print_WERROR(ndr, "result", r->out.result);
25146                 ndr->depth--;
25147         }
25148         ndr->depth--;
25149 }
25150
25151 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25152 {
25153         if (flags & NDR_IN) {
25154                 if (r->in.handle == NULL) {
25155                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25156                 }
25157                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25158                 if (r->in.devmode_ctr == NULL) {
25159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25160                 }
25161                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25162         }
25163         if (flags & NDR_OUT) {
25164                 if (r->out.gdi_handle == NULL) {
25165                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25166                 }
25167                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25168                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25169         }
25170         return NDR_ERR_SUCCESS;
25171 }
25172
25173 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25174 {
25175         TALLOC_CTX *_mem_save_handle_0;
25176         TALLOC_CTX *_mem_save_gdi_handle_0;
25177         TALLOC_CTX *_mem_save_devmode_ctr_0;
25178         if (flags & NDR_IN) {
25179                 ZERO_STRUCT(r->out);
25180
25181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25182                         NDR_PULL_ALLOC(ndr, r->in.handle);
25183                 }
25184                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25185                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25186                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25189                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25190                 }
25191                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25192                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25193                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25195                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25196                 ZERO_STRUCTP(r->out.gdi_handle);
25197         }
25198         if (flags & NDR_OUT) {
25199                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25200                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25201                 }
25202                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25203                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25204                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25207         }
25208         return NDR_ERR_SUCCESS;
25209 }
25210
25211 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25212 {
25213         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25214         ndr->depth++;
25215         if (flags & NDR_SET_VALUES) {
25216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25217         }
25218         if (flags & NDR_IN) {
25219                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25220                 ndr->depth++;
25221                 ndr_print_ptr(ndr, "handle", r->in.handle);
25222                 ndr->depth++;
25223                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25224                 ndr->depth--;
25225                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25226                 ndr->depth++;
25227                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25228                 ndr->depth--;
25229                 ndr->depth--;
25230         }
25231         if (flags & NDR_OUT) {
25232                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25233                 ndr->depth++;
25234                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25235                 ndr->depth++;
25236                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25237                 ndr->depth--;
25238                 ndr_print_WERROR(ndr, "result", r->out.result);
25239                 ndr->depth--;
25240         }
25241         ndr->depth--;
25242 }
25243
25244 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25245 {
25246         if (flags & NDR_IN) {
25247         }
25248         if (flags & NDR_OUT) {
25249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25250         }
25251         return NDR_ERR_SUCCESS;
25252 }
25253
25254 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25255 {
25256         if (flags & NDR_IN) {
25257         }
25258         if (flags & NDR_OUT) {
25259                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25260         }
25261         return NDR_ERR_SUCCESS;
25262 }
25263
25264 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25265 {
25266         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25267         ndr->depth++;
25268         if (flags & NDR_SET_VALUES) {
25269                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25270         }
25271         if (flags & NDR_IN) {
25272                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25273                 ndr->depth++;
25274                 ndr->depth--;
25275         }
25276         if (flags & NDR_OUT) {
25277                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25278                 ndr->depth++;
25279                 ndr_print_WERROR(ndr, "result", r->out.result);
25280                 ndr->depth--;
25281         }
25282         ndr->depth--;
25283 }
25284
25285 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25286 {
25287         if (flags & NDR_IN) {
25288                 if (r->in.gdi_handle == NULL) {
25289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25290                 }
25291                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25292         }
25293         if (flags & NDR_OUT) {
25294                 if (r->out.gdi_handle == NULL) {
25295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25296                 }
25297                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25298                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25299         }
25300         return NDR_ERR_SUCCESS;
25301 }
25302
25303 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25304 {
25305         TALLOC_CTX *_mem_save_gdi_handle_0;
25306         if (flags & NDR_IN) {
25307                 ZERO_STRUCT(r->out);
25308
25309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25310                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25311                 }
25312                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25313                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25314                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25316                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25317                 *r->out.gdi_handle = *r->in.gdi_handle;
25318         }
25319         if (flags & NDR_OUT) {
25320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25321                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25322                 }
25323                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25325                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25328         }
25329         return NDR_ERR_SUCCESS;
25330 }
25331
25332 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25333 {
25334         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25335         ndr->depth++;
25336         if (flags & NDR_SET_VALUES) {
25337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25338         }
25339         if (flags & NDR_IN) {
25340                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25341                 ndr->depth++;
25342                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25343                 ndr->depth++;
25344                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25345                 ndr->depth--;
25346                 ndr->depth--;
25347         }
25348         if (flags & NDR_OUT) {
25349                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25350                 ndr->depth++;
25351                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25352                 ndr->depth++;
25353                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25354                 ndr->depth--;
25355                 ndr_print_WERROR(ndr, "result", r->out.result);
25356                 ndr->depth--;
25357         }
25358         ndr->depth--;
25359 }
25360
25361 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25362 {
25363         if (flags & NDR_IN) {
25364         }
25365         if (flags & NDR_OUT) {
25366                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25367         }
25368         return NDR_ERR_SUCCESS;
25369 }
25370
25371 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25372 {
25373         if (flags & NDR_IN) {
25374         }
25375         if (flags & NDR_OUT) {
25376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25377         }
25378         return NDR_ERR_SUCCESS;
25379 }
25380
25381 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25382 {
25383         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25384         ndr->depth++;
25385         if (flags & NDR_SET_VALUES) {
25386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25387         }
25388         if (flags & NDR_IN) {
25389                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25390                 ndr->depth++;
25391                 ndr->depth--;
25392         }
25393         if (flags & NDR_OUT) {
25394                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25395                 ndr->depth++;
25396                 ndr_print_WERROR(ndr, "result", r->out.result);
25397                 ndr->depth--;
25398         }
25399         ndr->depth--;
25400 }
25401
25402 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25403 {
25404         if (flags & NDR_IN) {
25405         }
25406         if (flags & NDR_OUT) {
25407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25408         }
25409         return NDR_ERR_SUCCESS;
25410 }
25411
25412 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25413 {
25414         if (flags & NDR_IN) {
25415         }
25416         if (flags & NDR_OUT) {
25417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25418         }
25419         return NDR_ERR_SUCCESS;
25420 }
25421
25422 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25423 {
25424         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25425         ndr->depth++;
25426         if (flags & NDR_SET_VALUES) {
25427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25428         }
25429         if (flags & NDR_IN) {
25430                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25431                 ndr->depth++;
25432                 ndr->depth--;
25433         }
25434         if (flags & NDR_OUT) {
25435                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25436                 ndr->depth++;
25437                 ndr_print_WERROR(ndr, "result", r->out.result);
25438                 ndr->depth--;
25439         }
25440         ndr->depth--;
25441 }
25442
25443 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25444 {
25445         if (flags & NDR_IN) {
25446         }
25447         if (flags & NDR_OUT) {
25448                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25449         }
25450         return NDR_ERR_SUCCESS;
25451 }
25452
25453 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25454 {
25455         if (flags & NDR_IN) {
25456         }
25457         if (flags & NDR_OUT) {
25458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25459         }
25460         return NDR_ERR_SUCCESS;
25461 }
25462
25463 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25464 {
25465         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25466         ndr->depth++;
25467         if (flags & NDR_SET_VALUES) {
25468                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25469         }
25470         if (flags & NDR_IN) {
25471                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25472                 ndr->depth++;
25473                 ndr->depth--;
25474         }
25475         if (flags & NDR_OUT) {
25476                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25477                 ndr->depth++;
25478                 ndr_print_WERROR(ndr, "result", r->out.result);
25479                 ndr->depth--;
25480         }
25481         ndr->depth--;
25482 }
25483
25484 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25485 {
25486         if (flags & NDR_IN) {
25487         }
25488         if (flags & NDR_OUT) {
25489                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25490         }
25491         return NDR_ERR_SUCCESS;
25492 }
25493
25494 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25495 {
25496         if (flags & NDR_IN) {
25497         }
25498         if (flags & NDR_OUT) {
25499                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25500         }
25501         return NDR_ERR_SUCCESS;
25502 }
25503
25504 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25505 {
25506         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25507         ndr->depth++;
25508         if (flags & NDR_SET_VALUES) {
25509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25510         }
25511         if (flags & NDR_IN) {
25512                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25513                 ndr->depth++;
25514                 ndr->depth--;
25515         }
25516         if (flags & NDR_OUT) {
25517                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25518                 ndr->depth++;
25519                 ndr_print_WERROR(ndr, "result", r->out.result);
25520                 ndr->depth--;
25521         }
25522         ndr->depth--;
25523 }
25524
25525 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25526 {
25527         if (flags & NDR_IN) {
25528         }
25529         if (flags & NDR_OUT) {
25530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25531         }
25532         return NDR_ERR_SUCCESS;
25533 }
25534
25535 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25536 {
25537         if (flags & NDR_IN) {
25538         }
25539         if (flags & NDR_OUT) {
25540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25541         }
25542         return NDR_ERR_SUCCESS;
25543 }
25544
25545 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25546 {
25547         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25548         ndr->depth++;
25549         if (flags & NDR_SET_VALUES) {
25550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25551         }
25552         if (flags & NDR_IN) {
25553                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25554                 ndr->depth++;
25555                 ndr->depth--;
25556         }
25557         if (flags & NDR_OUT) {
25558                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25559                 ndr->depth++;
25560                 ndr_print_WERROR(ndr, "result", r->out.result);
25561                 ndr->depth--;
25562         }
25563         ndr->depth--;
25564 }
25565
25566 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25567 {
25568         if (flags & NDR_IN) {
25569         }
25570         if (flags & NDR_OUT) {
25571                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25572         }
25573         return NDR_ERR_SUCCESS;
25574 }
25575
25576 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25577 {
25578         if (flags & NDR_IN) {
25579         }
25580         if (flags & NDR_OUT) {
25581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25582         }
25583         return NDR_ERR_SUCCESS;
25584 }
25585
25586 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25587 {
25588         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25589         ndr->depth++;
25590         if (flags & NDR_SET_VALUES) {
25591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25592         }
25593         if (flags & NDR_IN) {
25594                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25595                 ndr->depth++;
25596                 ndr->depth--;
25597         }
25598         if (flags & NDR_OUT) {
25599                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25600                 ndr->depth++;
25601                 ndr_print_WERROR(ndr, "result", r->out.result);
25602                 ndr->depth--;
25603         }
25604         ndr->depth--;
25605 }
25606
25607 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25608 {
25609         if (flags & NDR_IN) {
25610         }
25611         if (flags & NDR_OUT) {
25612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25613         }
25614         return NDR_ERR_SUCCESS;
25615 }
25616
25617 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25618 {
25619         if (flags & NDR_IN) {
25620         }
25621         if (flags & NDR_OUT) {
25622                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25623         }
25624         return NDR_ERR_SUCCESS;
25625 }
25626
25627 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25628 {
25629         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25630         ndr->depth++;
25631         if (flags & NDR_SET_VALUES) {
25632                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25633         }
25634         if (flags & NDR_IN) {
25635                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25636                 ndr->depth++;
25637                 ndr->depth--;
25638         }
25639         if (flags & NDR_OUT) {
25640                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25641                 ndr->depth++;
25642                 ndr_print_WERROR(ndr, "result", r->out.result);
25643                 ndr->depth--;
25644         }
25645         ndr->depth--;
25646 }
25647
25648 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25649 {
25650         if (flags & NDR_IN) {
25651         }
25652         if (flags & NDR_OUT) {
25653                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25654         }
25655         return NDR_ERR_SUCCESS;
25656 }
25657
25658 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25659 {
25660         if (flags & NDR_IN) {
25661         }
25662         if (flags & NDR_OUT) {
25663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25664         }
25665         return NDR_ERR_SUCCESS;
25666 }
25667
25668 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25669 {
25670         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25671         ndr->depth++;
25672         if (flags & NDR_SET_VALUES) {
25673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25674         }
25675         if (flags & NDR_IN) {
25676                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25677                 ndr->depth++;
25678                 ndr->depth--;
25679         }
25680         if (flags & NDR_OUT) {
25681                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25682                 ndr->depth++;
25683                 ndr_print_WERROR(ndr, "result", r->out.result);
25684                 ndr->depth--;
25685         }
25686         ndr->depth--;
25687 }
25688
25689 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25690 {
25691         if (flags & NDR_IN) {
25692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25693                 if (r->in.servername) {
25694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25698                 }
25699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25700                 if (r->in.print_processor_name) {
25701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25704                         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));
25705                 }
25706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25708                 if (r->in.buffer) {
25709                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25710                 }
25711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25712         }
25713         if (flags & NDR_OUT) {
25714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25715                 if (r->out.info) {
25716                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25717                 }
25718                 if (r->out.needed == NULL) {
25719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25720                 }
25721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25722                 if (r->out.count == NULL) {
25723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25724                 }
25725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25726                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25727         }
25728         return NDR_ERR_SUCCESS;
25729 }
25730
25731 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25732 {
25733         uint32_t _ptr_servername;
25734         uint32_t _ptr_print_processor_name;
25735         uint32_t _ptr_buffer;
25736         uint32_t _ptr_info;
25737         TALLOC_CTX *_mem_save_servername_0;
25738         TALLOC_CTX *_mem_save_print_processor_name_0;
25739         TALLOC_CTX *_mem_save_buffer_0;
25740         TALLOC_CTX *_mem_save_info_0;
25741         TALLOC_CTX *_mem_save_needed_0;
25742         TALLOC_CTX *_mem_save_count_0;
25743         if (flags & NDR_IN) {
25744                 ZERO_STRUCT(r->out);
25745
25746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25747                 if (_ptr_servername) {
25748                         NDR_PULL_ALLOC(ndr, r->in.servername);
25749                 } else {
25750                         r->in.servername = NULL;
25751                 }
25752                 if (r->in.servername) {
25753                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25757                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25758                                 return 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));
25759                         }
25760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25763                 }
25764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25765                 if (_ptr_print_processor_name) {
25766                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25767                 } else {
25768                         r->in.print_processor_name = NULL;
25769                 }
25770                 if (r->in.print_processor_name) {
25771                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25772                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25775                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25776                                 return 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));
25777                         }
25778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25779                         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));
25780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25781                 }
25782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25784                 if (_ptr_buffer) {
25785                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25786                 } else {
25787                         r->in.buffer = NULL;
25788                 }
25789                 if (r->in.buffer) {
25790                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25792                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25794                 }
25795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25796                 NDR_PULL_ALLOC(ndr, r->out.needed);
25797                 ZERO_STRUCTP(r->out.needed);
25798                 NDR_PULL_ALLOC(ndr, r->out.count);
25799                 ZERO_STRUCTP(r->out.count);
25800         }
25801         if (flags & NDR_OUT) {
25802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25803                 if (_ptr_info) {
25804                         NDR_PULL_ALLOC(ndr, r->out.info);
25805                 } else {
25806                         r->out.info = NULL;
25807                 }
25808                 if (r->out.info) {
25809                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25810                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25811                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25813                 }
25814                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25815                         NDR_PULL_ALLOC(ndr, r->out.needed);
25816                 }
25817                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25818                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25820                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25822                         NDR_PULL_ALLOC(ndr, r->out.count);
25823                 }
25824                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25825                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25829         }
25830         return NDR_ERR_SUCCESS;
25831 }
25832
25833 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25834 {
25835         uint32_t cntr_info_0;
25836         if (flags & NDR_IN) {
25837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25839         }
25840         if (flags & NDR_OUT) {
25841                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25842                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25843                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25844                 }
25845                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25846                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25847                 }
25848         }
25849         return NDR_ERR_SUCCESS;
25850 }
25851
25852 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25853 {
25854         uint32_t cntr_info_0;
25855         TALLOC_CTX *_mem_save_info_0;
25856         if (flags & NDR_IN) {
25857                 ZERO_STRUCT(r->out);
25858
25859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25861         }
25862         if (flags & NDR_OUT) {
25863                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25864                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25866                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25867                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25868                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25869                 }
25870                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25871                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25872                 }
25873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25874         }
25875         return NDR_ERR_SUCCESS;
25876 }
25877
25878 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25879 {
25880         uint32_t cntr_info_2;
25881         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25882         ndr->depth++;
25883         if (flags & NDR_SET_VALUES) {
25884                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25885         }
25886         if (flags & NDR_IN) {
25887                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25888                 ndr->depth++;
25889                 ndr_print_ptr(ndr, "servername", r->in.servername);
25890                 ndr->depth++;
25891                 if (r->in.servername) {
25892                         ndr_print_string(ndr, "servername", r->in.servername);
25893                 }
25894                 ndr->depth--;
25895                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25896                 ndr->depth++;
25897                 if (r->in.print_processor_name) {
25898                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25899                 }
25900                 ndr->depth--;
25901                 ndr_print_uint32(ndr, "level", r->in.level);
25902                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25903                 ndr->depth++;
25904                 if (r->in.buffer) {
25905                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25906                 }
25907                 ndr->depth--;
25908                 ndr_print_uint32(ndr, "offered", r->in.offered);
25909                 ndr->depth--;
25910         }
25911         if (flags & NDR_OUT) {
25912                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25913                 ndr->depth++;
25914                 ndr_print_ptr(ndr, "count", r->out.count);
25915                 ndr->depth++;
25916                 ndr_print_uint32(ndr, "count", *r->out.count);
25917                 ndr->depth--;
25918                 ndr_print_ptr(ndr, "info", r->out.info);
25919                 ndr->depth++;
25920                 ndr_print_ptr(ndr, "info", *r->out.info);
25921                 ndr->depth++;
25922                 if (*r->out.info) {
25923                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25924                         ndr->depth++;
25925                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25926                                 char *idx_2=NULL;
25927                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25928                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25929                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25930                                         free(idx_2);
25931                                 }
25932                         }
25933                         ndr->depth--;
25934                 }
25935                 ndr->depth--;
25936                 ndr->depth--;
25937                 ndr_print_ptr(ndr, "needed", r->out.needed);
25938                 ndr->depth++;
25939                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25940                 ndr->depth--;
25941                 ndr_print_WERROR(ndr, "result", r->out.result);
25942                 ndr->depth--;
25943         }
25944         ndr->depth--;
25945 }
25946
25947 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25948 {
25949         if (flags & NDR_IN) {
25950                 if (r->in.handle == NULL) {
25951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25952                 }
25953                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25954                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25955                 if (r->in.data_type) {
25956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25959                         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));
25960                 }
25961                 if (r->in.devmode_ctr == NULL) {
25962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25963                 }
25964                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25965         }
25966         if (flags & NDR_OUT) {
25967                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25968         }
25969         return NDR_ERR_SUCCESS;
25970 }
25971
25972 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25973 {
25974         uint32_t _ptr_data_type;
25975         TALLOC_CTX *_mem_save_handle_0;
25976         TALLOC_CTX *_mem_save_data_type_0;
25977         TALLOC_CTX *_mem_save_devmode_ctr_0;
25978         if (flags & NDR_IN) {
25979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25980                         NDR_PULL_ALLOC(ndr, r->in.handle);
25981                 }
25982                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25984                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25987                 if (_ptr_data_type) {
25988                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25989                 } else {
25990                         r->in.data_type = NULL;
25991                 }
25992                 if (r->in.data_type) {
25993                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25994                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25997                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
25998                                 return 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));
25999                         }
26000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26001                         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));
26002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26003                 }
26004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26005                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26006                 }
26007                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26008                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26009                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26010                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
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_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26019 {
26020         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
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_ResetPrinter");
26027                 ndr->depth++;
26028                 ndr_print_ptr(ndr, "handle", r->in.handle);
26029                 ndr->depth++;
26030                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26031                 ndr->depth--;
26032                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26033                 ndr->depth++;
26034                 if (r->in.data_type) {
26035                         ndr_print_string(ndr, "data_type", r->in.data_type);
26036                 }
26037                 ndr->depth--;
26038                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26039                 ndr->depth++;
26040                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26041                 ndr->depth--;
26042                 ndr->depth--;
26043         }
26044         if (flags & NDR_OUT) {
26045                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26046                 ndr->depth++;
26047                 ndr_print_WERROR(ndr, "result", r->out.result);
26048                 ndr->depth--;
26049         }
26050         ndr->depth--;
26051 }
26052
26053 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26054 {
26055         if (flags & NDR_IN) {
26056                 if (r->in.handle == NULL) {
26057                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26058                 }
26059                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26061                 if (r->in.architecture) {
26062                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26066                 }
26067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26069                 if (r->in.buffer) {
26070                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26071                 }
26072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26075         }
26076         if (flags & NDR_OUT) {
26077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26078                 if (r->out.info) {
26079                         {
26080                                 struct ndr_push *_ndr_info;
26081                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26082                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26083                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26084                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26085                         }
26086                 }
26087                 if (r->out.needed == NULL) {
26088                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26089                 }
26090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26091                 if (r->out.server_major_version == NULL) {
26092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26093                 }
26094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26095                 if (r->out.server_minor_version == NULL) {
26096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26097                 }
26098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26100         }
26101         return NDR_ERR_SUCCESS;
26102 }
26103
26104 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26105 {
26106         uint32_t _ptr_architecture;
26107         uint32_t _ptr_buffer;
26108         uint32_t _ptr_info;
26109         TALLOC_CTX *_mem_save_handle_0;
26110         TALLOC_CTX *_mem_save_architecture_0;
26111         TALLOC_CTX *_mem_save_buffer_0;
26112         TALLOC_CTX *_mem_save_info_0;
26113         TALLOC_CTX *_mem_save_needed_0;
26114         TALLOC_CTX *_mem_save_server_major_version_0;
26115         TALLOC_CTX *_mem_save_server_minor_version_0;
26116         if (flags & NDR_IN) {
26117                 ZERO_STRUCT(r->out);
26118
26119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26120                         NDR_PULL_ALLOC(ndr, r->in.handle);
26121                 }
26122                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26123                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26124                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26125                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26127                 if (_ptr_architecture) {
26128                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26129                 } else {
26130                         r->in.architecture = NULL;
26131                 }
26132                 if (r->in.architecture) {
26133                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26134                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26136                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26137                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26138                                 return 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));
26139                         }
26140                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26141                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26143                 }
26144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26146                 if (_ptr_buffer) {
26147                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26148                 } else {
26149                         r->in.buffer = NULL;
26150                 }
26151                 if (r->in.buffer) {
26152                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26153                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26154                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26156                 }
26157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26160                 NDR_PULL_ALLOC(ndr, r->out.needed);
26161                 ZERO_STRUCTP(r->out.needed);
26162                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26163                 ZERO_STRUCTP(r->out.server_major_version);
26164                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26165                 ZERO_STRUCTP(r->out.server_minor_version);
26166         }
26167         if (flags & NDR_OUT) {
26168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26169                 if (_ptr_info) {
26170                         NDR_PULL_ALLOC(ndr, r->out.info);
26171                 } else {
26172                         r->out.info = NULL;
26173                 }
26174                 if (r->out.info) {
26175                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26176                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26177                         {
26178                                 struct ndr_pull *_ndr_info;
26179                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26180                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26181                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26182                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26183                         }
26184                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26185                 }
26186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26187                         NDR_PULL_ALLOC(ndr, r->out.needed);
26188                 }
26189                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26193                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26194                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26195                 }
26196                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26197                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26199                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26201                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26202                 }
26203                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26204                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26207                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26208         }
26209         return NDR_ERR_SUCCESS;
26210 }
26211
26212 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26213 {
26214         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26215         ndr->depth++;
26216         if (flags & NDR_SET_VALUES) {
26217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26218         }
26219         if (flags & NDR_IN) {
26220                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26221                 ndr->depth++;
26222                 ndr_print_ptr(ndr, "handle", r->in.handle);
26223                 ndr->depth++;
26224                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26225                 ndr->depth--;
26226                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26227                 ndr->depth++;
26228                 if (r->in.architecture) {
26229                         ndr_print_string(ndr, "architecture", r->in.architecture);
26230                 }
26231                 ndr->depth--;
26232                 ndr_print_uint32(ndr, "level", r->in.level);
26233                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26234                 ndr->depth++;
26235                 if (r->in.buffer) {
26236                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26237                 }
26238                 ndr->depth--;
26239                 ndr_print_uint32(ndr, "offered", r->in.offered);
26240                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26241                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26242                 ndr->depth--;
26243         }
26244         if (flags & NDR_OUT) {
26245                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26246                 ndr->depth++;
26247                 ndr_print_ptr(ndr, "info", r->out.info);
26248                 ndr->depth++;
26249                 if (r->out.info) {
26250                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26251                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26252                 }
26253                 ndr->depth--;
26254                 ndr_print_ptr(ndr, "needed", r->out.needed);
26255                 ndr->depth++;
26256                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26257                 ndr->depth--;
26258                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26259                 ndr->depth++;
26260                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26261                 ndr->depth--;
26262                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26263                 ndr->depth++;
26264                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26265                 ndr->depth--;
26266                 ndr_print_WERROR(ndr, "result", r->out.result);
26267                 ndr->depth--;
26268         }
26269         ndr->depth--;
26270 }
26271
26272 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26273 {
26274         if (flags & NDR_IN) {
26275         }
26276         if (flags & NDR_OUT) {
26277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26278         }
26279         return NDR_ERR_SUCCESS;
26280 }
26281
26282 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26283 {
26284         if (flags & NDR_IN) {
26285         }
26286         if (flags & NDR_OUT) {
26287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26288         }
26289         return NDR_ERR_SUCCESS;
26290 }
26291
26292 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26293 {
26294         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26295         ndr->depth++;
26296         if (flags & NDR_SET_VALUES) {
26297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26298         }
26299         if (flags & NDR_IN) {
26300                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26301                 ndr->depth++;
26302                 ndr->depth--;
26303         }
26304         if (flags & NDR_OUT) {
26305                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26306                 ndr->depth++;
26307                 ndr_print_WERROR(ndr, "result", r->out.result);
26308                 ndr->depth--;
26309         }
26310         ndr->depth--;
26311 }
26312
26313 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26314 {
26315         if (flags & NDR_IN) {
26316         }
26317         if (flags & NDR_OUT) {
26318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26319         }
26320         return NDR_ERR_SUCCESS;
26321 }
26322
26323 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26324 {
26325         if (flags & NDR_IN) {
26326         }
26327         if (flags & NDR_OUT) {
26328                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26329         }
26330         return NDR_ERR_SUCCESS;
26331 }
26332
26333 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26334 {
26335         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26336         ndr->depth++;
26337         if (flags & NDR_SET_VALUES) {
26338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26339         }
26340         if (flags & NDR_IN) {
26341                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26342                 ndr->depth++;
26343                 ndr->depth--;
26344         }
26345         if (flags & NDR_OUT) {
26346                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26347                 ndr->depth++;
26348                 ndr_print_WERROR(ndr, "result", r->out.result);
26349                 ndr->depth--;
26350         }
26351         ndr->depth--;
26352 }
26353
26354 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26355 {
26356         if (flags & NDR_IN) {
26357                 if (r->in.handle == NULL) {
26358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26359                 }
26360                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26361         }
26362         if (flags & NDR_OUT) {
26363                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26364         }
26365         return NDR_ERR_SUCCESS;
26366 }
26367
26368 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26369 {
26370         TALLOC_CTX *_mem_save_handle_0;
26371         if (flags & NDR_IN) {
26372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26373                         NDR_PULL_ALLOC(ndr, r->in.handle);
26374                 }
26375                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26376                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26377                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26379         }
26380         if (flags & NDR_OUT) {
26381                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26382         }
26383         return NDR_ERR_SUCCESS;
26384 }
26385
26386 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26387 {
26388         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26389         ndr->depth++;
26390         if (flags & NDR_SET_VALUES) {
26391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26392         }
26393         if (flags & NDR_IN) {
26394                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26395                 ndr->depth++;
26396                 ndr_print_ptr(ndr, "handle", r->in.handle);
26397                 ndr->depth++;
26398                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26399                 ndr->depth--;
26400                 ndr->depth--;
26401         }
26402         if (flags & NDR_OUT) {
26403                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26404                 ndr->depth++;
26405                 ndr_print_WERROR(ndr, "result", r->out.result);
26406                 ndr->depth--;
26407         }
26408         ndr->depth--;
26409 }
26410
26411 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26412 {
26413         if (flags & NDR_IN) {
26414         }
26415         if (flags & NDR_OUT) {
26416                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26417         }
26418         return NDR_ERR_SUCCESS;
26419 }
26420
26421 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26422 {
26423         if (flags & NDR_IN) {
26424         }
26425         if (flags & NDR_OUT) {
26426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26427         }
26428         return NDR_ERR_SUCCESS;
26429 }
26430
26431 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26432 {
26433         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26434         ndr->depth++;
26435         if (flags & NDR_SET_VALUES) {
26436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26437         }
26438         if (flags & NDR_IN) {
26439                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26440                 ndr->depth++;
26441                 ndr->depth--;
26442         }
26443         if (flags & NDR_OUT) {
26444                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26445                 ndr->depth++;
26446                 ndr_print_WERROR(ndr, "result", r->out.result);
26447                 ndr->depth--;
26448         }
26449         ndr->depth--;
26450 }
26451
26452 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26453 {
26454         if (flags & NDR_IN) {
26455                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26456                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26457                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26458                 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));
26459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26460                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26462                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26463                 if (r->in.buffer) {
26464                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26465                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26466                 }
26467         }
26468         if (flags & NDR_OUT) {
26469                 if (r->out.handle == NULL) {
26470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26471                 }
26472                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26473                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26474         }
26475         return NDR_ERR_SUCCESS;
26476 }
26477
26478 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26479 {
26480         uint32_t _ptr_buffer;
26481         TALLOC_CTX *_mem_save_buffer_0;
26482         TALLOC_CTX *_mem_save_handle_0;
26483         if (flags & NDR_IN) {
26484                 ZERO_STRUCT(r->out);
26485
26486                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26487                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26488                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26489                         return 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));
26490                 }
26491                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26492                 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));
26493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26494                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26496                 if (r->in.bufsize > 512) {
26497                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26498                 }
26499                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26500                 if (_ptr_buffer) {
26501                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26502                 } else {
26503                         r->in.buffer = NULL;
26504                 }
26505                 if (r->in.buffer) {
26506                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26507                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26508                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26509                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26510                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26512                 }
26513                 NDR_PULL_ALLOC(ndr, r->out.handle);
26514                 ZERO_STRUCTP(r->out.handle);
26515                 if (r->in.buffer) {
26516                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26517                 }
26518         }
26519         if (flags & NDR_OUT) {
26520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26521                         NDR_PULL_ALLOC(ndr, r->out.handle);
26522                 }
26523                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26524                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26527                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26528         }
26529         return NDR_ERR_SUCCESS;
26530 }
26531
26532 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26533 {
26534         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26535         ndr->depth++;
26536         if (flags & NDR_SET_VALUES) {
26537                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26538         }
26539         if (flags & NDR_IN) {
26540                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26541                 ndr->depth++;
26542                 ndr_print_string(ndr, "server_name", r->in.server_name);
26543                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26544                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26545                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26546                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26547                 ndr->depth++;
26548                 if (r->in.buffer) {
26549                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26550                 }
26551                 ndr->depth--;
26552                 ndr->depth--;
26553         }
26554         if (flags & NDR_OUT) {
26555                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26556                 ndr->depth++;
26557                 ndr_print_ptr(ndr, "handle", r->out.handle);
26558                 ndr->depth++;
26559                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26560                 ndr->depth--;
26561                 ndr_print_WERROR(ndr, "result", r->out.result);
26562                 ndr->depth--;
26563         }
26564         ndr->depth--;
26565 }
26566
26567 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26568 {
26569         if (flags & NDR_IN) {
26570                 if (r->in.handle == NULL) {
26571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26572                 }
26573                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26574                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26576                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26577                 if (r->in.buffer) {
26578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26579                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26580                 }
26581         }
26582         if (flags & NDR_OUT) {
26583                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26584         }
26585         return NDR_ERR_SUCCESS;
26586 }
26587
26588 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26589 {
26590         uint32_t _ptr_buffer;
26591         TALLOC_CTX *_mem_save_handle_0;
26592         TALLOC_CTX *_mem_save_buffer_0;
26593         if (flags & NDR_IN) {
26594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26595                         NDR_PULL_ALLOC(ndr, r->in.handle);
26596                 }
26597                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26598                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26599                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26601                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26603                 if (r->in.bufsize > 512) {
26604                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26605                 }
26606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26607                 if (_ptr_buffer) {
26608                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26609                 } else {
26610                         r->in.buffer = NULL;
26611                 }
26612                 if (r->in.buffer) {
26613                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26616                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26617                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26619                 }
26620                 if (r->in.buffer) {
26621                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26622                 }
26623         }
26624         if (flags & NDR_OUT) {
26625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26626         }
26627         return NDR_ERR_SUCCESS;
26628 }
26629
26630 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26631 {
26632         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26633         ndr->depth++;
26634         if (flags & NDR_SET_VALUES) {
26635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26636         }
26637         if (flags & NDR_IN) {
26638                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26639                 ndr->depth++;
26640                 ndr_print_ptr(ndr, "handle", r->in.handle);
26641                 ndr->depth++;
26642                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26643                 ndr->depth--;
26644                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26645                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26646                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26647                 ndr->depth++;
26648                 if (r->in.buffer) {
26649                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26650                 }
26651                 ndr->depth--;
26652                 ndr->depth--;
26653         }
26654         if (flags & NDR_OUT) {
26655                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26656                 ndr->depth++;
26657                 ndr_print_WERROR(ndr, "result", r->out.result);
26658                 ndr->depth--;
26659         }
26660         ndr->depth--;
26661 }
26662
26663 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26664 {
26665         if (flags & NDR_IN) {
26666                 if (r->in.handle == NULL) {
26667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26668                 }
26669                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26670         }
26671         if (flags & NDR_OUT) {
26672                 if (r->out.handle == NULL) {
26673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26674                 }
26675                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26677         }
26678         return NDR_ERR_SUCCESS;
26679 }
26680
26681 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26682 {
26683         TALLOC_CTX *_mem_save_handle_0;
26684         if (flags & NDR_IN) {
26685                 ZERO_STRUCT(r->out);
26686
26687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26688                         NDR_PULL_ALLOC(ndr, r->in.handle);
26689                 }
26690                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26691                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26692                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26694                 NDR_PULL_ALLOC(ndr, r->out.handle);
26695                 *r->out.handle = *r->in.handle;
26696         }
26697         if (flags & NDR_OUT) {
26698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26699                         NDR_PULL_ALLOC(ndr, r->out.handle);
26700                 }
26701                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26703                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26705                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26706         }
26707         return NDR_ERR_SUCCESS;
26708 }
26709
26710 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26711 {
26712         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26713         ndr->depth++;
26714         if (flags & NDR_SET_VALUES) {
26715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26716         }
26717         if (flags & NDR_IN) {
26718                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26719                 ndr->depth++;
26720                 ndr_print_ptr(ndr, "handle", r->in.handle);
26721                 ndr->depth++;
26722                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26723                 ndr->depth--;
26724                 ndr->depth--;
26725         }
26726         if (flags & NDR_OUT) {
26727                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26728                 ndr->depth++;
26729                 ndr_print_ptr(ndr, "handle", r->out.handle);
26730                 ndr->depth++;
26731                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26732                 ndr->depth--;
26733                 ndr_print_WERROR(ndr, "result", r->out.result);
26734                 ndr->depth--;
26735         }
26736         ndr->depth--;
26737 }
26738
26739 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26740 {
26741         if (flags & NDR_IN) {
26742         }
26743         if (flags & NDR_OUT) {
26744                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26745         }
26746         return NDR_ERR_SUCCESS;
26747 }
26748
26749 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26750 {
26751         if (flags & NDR_IN) {
26752         }
26753         if (flags & NDR_OUT) {
26754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26755         }
26756         return NDR_ERR_SUCCESS;
26757 }
26758
26759 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26760 {
26761         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26762         ndr->depth++;
26763         if (flags & NDR_SET_VALUES) {
26764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26765         }
26766         if (flags & NDR_IN) {
26767                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26768                 ndr->depth++;
26769                 ndr->depth--;
26770         }
26771         if (flags & NDR_OUT) {
26772                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26773                 ndr->depth++;
26774                 ndr_print_WERROR(ndr, "result", r->out.result);
26775                 ndr->depth--;
26776         }
26777         ndr->depth--;
26778 }
26779
26780 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26781 {
26782         if (flags & NDR_IN) {
26783         }
26784         if (flags & NDR_OUT) {
26785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26786         }
26787         return NDR_ERR_SUCCESS;
26788 }
26789
26790 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26791 {
26792         if (flags & NDR_IN) {
26793         }
26794         if (flags & NDR_OUT) {
26795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26796         }
26797         return NDR_ERR_SUCCESS;
26798 }
26799
26800 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26801 {
26802         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26803         ndr->depth++;
26804         if (flags & NDR_SET_VALUES) {
26805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26806         }
26807         if (flags & NDR_IN) {
26808                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26809                 ndr->depth++;
26810                 ndr->depth--;
26811         }
26812         if (flags & NDR_OUT) {
26813                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26814                 ndr->depth++;
26815                 ndr_print_WERROR(ndr, "result", r->out.result);
26816                 ndr->depth--;
26817         }
26818         ndr->depth--;
26819 }
26820
26821 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26822 {
26823         if (flags & NDR_IN) {
26824         }
26825         if (flags & NDR_OUT) {
26826                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26827         }
26828         return NDR_ERR_SUCCESS;
26829 }
26830
26831 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26832 {
26833         if (flags & NDR_IN) {
26834         }
26835         if (flags & NDR_OUT) {
26836                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26837         }
26838         return NDR_ERR_SUCCESS;
26839 }
26840
26841 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26842 {
26843         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26844         ndr->depth++;
26845         if (flags & NDR_SET_VALUES) {
26846                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26847         }
26848         if (flags & NDR_IN) {
26849                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26850                 ndr->depth++;
26851                 ndr->depth--;
26852         }
26853         if (flags & NDR_OUT) {
26854                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26855                 ndr->depth++;
26856                 ndr_print_WERROR(ndr, "result", r->out.result);
26857                 ndr->depth--;
26858         }
26859         ndr->depth--;
26860 }
26861
26862 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26863 {
26864         if (flags & NDR_IN) {
26865         }
26866         if (flags & NDR_OUT) {
26867                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26868         }
26869         return NDR_ERR_SUCCESS;
26870 }
26871
26872 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26873 {
26874         if (flags & NDR_IN) {
26875         }
26876         if (flags & NDR_OUT) {
26877                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26878         }
26879         return NDR_ERR_SUCCESS;
26880 }
26881
26882 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26883 {
26884         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26885         ndr->depth++;
26886         if (flags & NDR_SET_VALUES) {
26887                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26888         }
26889         if (flags & NDR_IN) {
26890                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26891                 ndr->depth++;
26892                 ndr->depth--;
26893         }
26894         if (flags & NDR_OUT) {
26895                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26896                 ndr->depth++;
26897                 ndr_print_WERROR(ndr, "result", r->out.result);
26898                 ndr->depth--;
26899         }
26900         ndr->depth--;
26901 }
26902
26903 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26904 {
26905         if (flags & NDR_IN) {
26906                 if (r->in.handle == NULL) {
26907                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26908                 }
26909                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26910                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26913                 if (r->in.local_machine) {
26914                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26917                         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));
26918                 }
26919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26921                 if (r->in.notify_options) {
26922                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26923                 }
26924         }
26925         if (flags & NDR_OUT) {
26926                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26927         }
26928         return NDR_ERR_SUCCESS;
26929 }
26930
26931 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26932 {
26933         uint32_t _ptr_local_machine;
26934         uint32_t _ptr_notify_options;
26935         TALLOC_CTX *_mem_save_handle_0;
26936         TALLOC_CTX *_mem_save_local_machine_0;
26937         TALLOC_CTX *_mem_save_notify_options_0;
26938         if (flags & NDR_IN) {
26939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26940                         NDR_PULL_ALLOC(ndr, r->in.handle);
26941                 }
26942                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26943                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26944                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26946                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26949                 if (_ptr_local_machine) {
26950                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26951                 } else {
26952                         r->in.local_machine = NULL;
26953                 }
26954                 if (r->in.local_machine) {
26955                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26956                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26959                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26960                                 return 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));
26961                         }
26962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26963                         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));
26964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26965                 }
26966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26968                 if (_ptr_notify_options) {
26969                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26970                 } else {
26971                         r->in.notify_options = NULL;
26972                 }
26973                 if (r->in.notify_options) {
26974                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26975                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26976                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26978                 }
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_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26987 {
26988         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
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_RemoteFindFirstPrinterChangeNotifyEx");
26995                 ndr->depth++;
26996                 ndr_print_ptr(ndr, "handle", r->in.handle);
26997                 ndr->depth++;
26998                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26999                 ndr->depth--;
27000                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27001                 ndr_print_uint32(ndr, "options", r->in.options);
27002                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27003                 ndr->depth++;
27004                 if (r->in.local_machine) {
27005                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27006                 }
27007                 ndr->depth--;
27008                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27009                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27010                 ndr->depth++;
27011                 if (r->in.notify_options) {
27012                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27013                 }
27014                 ndr->depth--;
27015                 ndr->depth--;
27016         }
27017         if (flags & NDR_OUT) {
27018                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27019                 ndr->depth++;
27020                 ndr_print_WERROR(ndr, "result", r->out.result);
27021                 ndr->depth--;
27022         }
27023         ndr->depth--;
27024 }
27025
27026 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27027 {
27028         if (flags & NDR_IN) {
27029                 if (r->in.handle == NULL) {
27030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27031                 }
27032                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27034                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27036                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27037                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27038         }
27039         if (flags & NDR_OUT) {
27040                 if (r->out.reply_result == NULL) {
27041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27042                 }
27043                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27044                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27045         }
27046         return NDR_ERR_SUCCESS;
27047 }
27048
27049 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27050 {
27051         TALLOC_CTX *_mem_save_handle_0;
27052         TALLOC_CTX *_mem_save_reply_result_0;
27053         if (flags & NDR_IN) {
27054                 ZERO_STRUCT(r->out);
27055
27056                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27057                         NDR_PULL_ALLOC(ndr, r->in.handle);
27058                 }
27059                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27060                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27061                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27062                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27064                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27066                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27067                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27068                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27069                 ZERO_STRUCTP(r->out.reply_result);
27070         }
27071         if (flags & NDR_OUT) {
27072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27073                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27074                 }
27075                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27076                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27077                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27080         }
27081         return NDR_ERR_SUCCESS;
27082 }
27083
27084 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27085 {
27086         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27087         ndr->depth++;
27088         if (flags & NDR_SET_VALUES) {
27089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27090         }
27091         if (flags & NDR_IN) {
27092                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27093                 ndr->depth++;
27094                 ndr_print_ptr(ndr, "handle", r->in.handle);
27095                 ndr->depth++;
27096                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27097                 ndr->depth--;
27098                 ndr_print_uint32(ndr, "color", r->in.color);
27099                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27100                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27101                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27102                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27103                 ndr->depth--;
27104         }
27105         if (flags & NDR_OUT) {
27106                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27107                 ndr->depth++;
27108                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27109                 ndr->depth++;
27110                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27111                 ndr->depth--;
27112                 ndr_print_WERROR(ndr, "result", r->out.result);
27113                 ndr->depth--;
27114         }
27115         ndr->depth--;
27116 }
27117
27118 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27119 {
27120         if (flags & NDR_IN) {
27121                 if (r->in.handle == NULL) {
27122                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27123                 }
27124                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27126                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27127                 if (r->in.options) {
27128                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27129                 }
27130         }
27131         if (flags & NDR_OUT) {
27132                 if (r->out.info == NULL) {
27133                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27134                 }
27135                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27136                 if (*r->out.info) {
27137                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27138                 }
27139                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27140         }
27141         return NDR_ERR_SUCCESS;
27142 }
27143
27144 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27145 {
27146         uint32_t _ptr_options;
27147         uint32_t _ptr_info;
27148         TALLOC_CTX *_mem_save_handle_0;
27149         TALLOC_CTX *_mem_save_options_0;
27150         TALLOC_CTX *_mem_save_info_0;
27151         TALLOC_CTX *_mem_save_info_1;
27152         if (flags & NDR_IN) {
27153                 ZERO_STRUCT(r->out);
27154
27155                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27156                         NDR_PULL_ALLOC(ndr, r->in.handle);
27157                 }
27158                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27159                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27160                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27164                 if (_ptr_options) {
27165                         NDR_PULL_ALLOC(ndr, r->in.options);
27166                 } else {
27167                         r->in.options = NULL;
27168                 }
27169                 if (r->in.options) {
27170                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27171                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27172                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27174                 }
27175                 NDR_PULL_ALLOC(ndr, r->out.info);
27176                 ZERO_STRUCTP(r->out.info);
27177         }
27178         if (flags & NDR_OUT) {
27179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27180                         NDR_PULL_ALLOC(ndr, r->out.info);
27181                 }
27182                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27185                 if (_ptr_info) {
27186                         NDR_PULL_ALLOC(ndr, *r->out.info);
27187                 } else {
27188                         *r->out.info = NULL;
27189                 }
27190                 if (*r->out.info) {
27191                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27192                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27193                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27195                 }
27196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27198         }
27199         return NDR_ERR_SUCCESS;
27200 }
27201
27202 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27203 {
27204         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27205         ndr->depth++;
27206         if (flags & NDR_SET_VALUES) {
27207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27208         }
27209         if (flags & NDR_IN) {
27210                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27211                 ndr->depth++;
27212                 ndr_print_ptr(ndr, "handle", r->in.handle);
27213                 ndr->depth++;
27214                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27215                 ndr->depth--;
27216                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27217                 ndr_print_ptr(ndr, "options", r->in.options);
27218                 ndr->depth++;
27219                 if (r->in.options) {
27220                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27221                 }
27222                 ndr->depth--;
27223                 ndr->depth--;
27224         }
27225         if (flags & NDR_OUT) {
27226                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27227                 ndr->depth++;
27228                 ndr_print_ptr(ndr, "info", r->out.info);
27229                 ndr->depth++;
27230                 ndr_print_ptr(ndr, "info", *r->out.info);
27231                 ndr->depth++;
27232                 if (*r->out.info) {
27233                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27234                 }
27235                 ndr->depth--;
27236                 ndr->depth--;
27237                 ndr_print_WERROR(ndr, "result", r->out.result);
27238                 ndr->depth--;
27239         }
27240         ndr->depth--;
27241 }
27242
27243 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27244 {
27245         if (flags & NDR_IN) {
27246         }
27247         if (flags & NDR_OUT) {
27248                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27249         }
27250         return NDR_ERR_SUCCESS;
27251 }
27252
27253 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27254 {
27255         if (flags & NDR_IN) {
27256         }
27257         if (flags & NDR_OUT) {
27258                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27259         }
27260         return NDR_ERR_SUCCESS;
27261 }
27262
27263 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27264 {
27265         ndr_print_struct(ndr, name, "spoolss_44");
27266         ndr->depth++;
27267         if (flags & NDR_SET_VALUES) {
27268                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27269         }
27270         if (flags & NDR_IN) {
27271                 ndr_print_struct(ndr, "in", "spoolss_44");
27272                 ndr->depth++;
27273                 ndr->depth--;
27274         }
27275         if (flags & NDR_OUT) {
27276                 ndr_print_struct(ndr, "out", "spoolss_44");
27277                 ndr->depth++;
27278                 ndr_print_WERROR(ndr, "result", r->out.result);
27279                 ndr->depth--;
27280         }
27281         ndr->depth--;
27282 }
27283
27284 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27285 {
27286         if (flags & NDR_IN) {
27287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27288                 if (r->in.printername) {
27289                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27293                 }
27294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27295                 if (r->in.datatype) {
27296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27297                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27300                 }
27301                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27302                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27304                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27305                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27306         }
27307         if (flags & NDR_OUT) {
27308                 if (r->out.handle == NULL) {
27309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27310                 }
27311                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27312                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27313         }
27314         return NDR_ERR_SUCCESS;
27315 }
27316
27317 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27318 {
27319         uint32_t _ptr_printername;
27320         uint32_t _ptr_datatype;
27321         TALLOC_CTX *_mem_save_printername_0;
27322         TALLOC_CTX *_mem_save_datatype_0;
27323         TALLOC_CTX *_mem_save_handle_0;
27324         if (flags & NDR_IN) {
27325                 ZERO_STRUCT(r->out);
27326
27327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27328                 if (_ptr_printername) {
27329                         NDR_PULL_ALLOC(ndr, r->in.printername);
27330                 } else {
27331                         r->in.printername = NULL;
27332                 }
27333                 if (r->in.printername) {
27334                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27335                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27338                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27339                                 return 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));
27340                         }
27341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27344                 }
27345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27346                 if (_ptr_datatype) {
27347                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27348                 } else {
27349                         r->in.datatype = NULL;
27350                 }
27351                 if (r->in.datatype) {
27352                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27353                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27356                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27357                                 return 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));
27358                         }
27359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27362                 }
27363                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27364                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27366                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27367                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27368                 NDR_PULL_ALLOC(ndr, r->out.handle);
27369                 ZERO_STRUCTP(r->out.handle);
27370         }
27371         if (flags & NDR_OUT) {
27372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27373                         NDR_PULL_ALLOC(ndr, r->out.handle);
27374                 }
27375                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27376                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27377                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27380         }
27381         return NDR_ERR_SUCCESS;
27382 }
27383
27384 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27385 {
27386         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27387         ndr->depth++;
27388         if (flags & NDR_SET_VALUES) {
27389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27390         }
27391         if (flags & NDR_IN) {
27392                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27393                 ndr->depth++;
27394                 ndr_print_ptr(ndr, "printername", r->in.printername);
27395                 ndr->depth++;
27396                 if (r->in.printername) {
27397                         ndr_print_string(ndr, "printername", r->in.printername);
27398                 }
27399                 ndr->depth--;
27400                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27401                 ndr->depth++;
27402                 if (r->in.datatype) {
27403                         ndr_print_string(ndr, "datatype", r->in.datatype);
27404                 }
27405                 ndr->depth--;
27406                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27407                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27408                 ndr_print_uint32(ndr, "level", r->in.level);
27409                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27410                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27411                 ndr->depth--;
27412         }
27413         if (flags & NDR_OUT) {
27414                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27415                 ndr->depth++;
27416                 ndr_print_ptr(ndr, "handle", r->out.handle);
27417                 ndr->depth++;
27418                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27419                 ndr->depth--;
27420                 ndr_print_WERROR(ndr, "result", r->out.result);
27421                 ndr->depth--;
27422         }
27423         ndr->depth--;
27424 }
27425
27426 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27427 {
27428         if (flags & NDR_IN) {
27429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27430                 if (r->in.server) {
27431                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27432                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27435                 }
27436                 if (r->in.info_ctr == NULL) {
27437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27438                 }
27439                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27440                 if (r->in.devmode_ctr == NULL) {
27441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27442                 }
27443                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27444                 if (r->in.secdesc_ctr == NULL) {
27445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27446                 }
27447                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27448                 if (r->in.userlevel_ctr == NULL) {
27449                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27450                 }
27451                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27452         }
27453         if (flags & NDR_OUT) {
27454                 if (r->out.handle == NULL) {
27455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27456                 }
27457                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27459         }
27460         return NDR_ERR_SUCCESS;
27461 }
27462
27463 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27464 {
27465         uint32_t _ptr_server;
27466         TALLOC_CTX *_mem_save_server_0;
27467         TALLOC_CTX *_mem_save_info_ctr_0;
27468         TALLOC_CTX *_mem_save_devmode_ctr_0;
27469         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27470         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27471         TALLOC_CTX *_mem_save_handle_0;
27472         if (flags & NDR_IN) {
27473                 ZERO_STRUCT(r->out);
27474
27475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27476                 if (_ptr_server) {
27477                         NDR_PULL_ALLOC(ndr, r->in.server);
27478                 } else {
27479                         r->in.server = NULL;
27480                 }
27481                 if (r->in.server) {
27482                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27483                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27484                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27485                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27486                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27487                                 return 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));
27488                         }
27489                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27490                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27492                 }
27493                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27494                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27495                 }
27496                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27497                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27498                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27499                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27500                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27501                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27502                 }
27503                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27504                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27505                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27506                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27508                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27509                 }
27510                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27511                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27512                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27515                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27516                 }
27517                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27518                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27519                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27521                 NDR_PULL_ALLOC(ndr, r->out.handle);
27522                 ZERO_STRUCTP(r->out.handle);
27523         }
27524         if (flags & NDR_OUT) {
27525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27526                         NDR_PULL_ALLOC(ndr, r->out.handle);
27527                 }
27528                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27529                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27530                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27531                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27532                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27533         }
27534         return NDR_ERR_SUCCESS;
27535 }
27536
27537 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27538 {
27539         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27540         ndr->depth++;
27541         if (flags & NDR_SET_VALUES) {
27542                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27543         }
27544         if (flags & NDR_IN) {
27545                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27546                 ndr->depth++;
27547                 ndr_print_ptr(ndr, "server", r->in.server);
27548                 ndr->depth++;
27549                 if (r->in.server) {
27550                         ndr_print_string(ndr, "server", r->in.server);
27551                 }
27552                 ndr->depth--;
27553                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27554                 ndr->depth++;
27555                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27556                 ndr->depth--;
27557                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27558                 ndr->depth++;
27559                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27560                 ndr->depth--;
27561                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27562                 ndr->depth++;
27563                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27564                 ndr->depth--;
27565                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27566                 ndr->depth++;
27567                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27568                 ndr->depth--;
27569                 ndr->depth--;
27570         }
27571         if (flags & NDR_OUT) {
27572                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27573                 ndr->depth++;
27574                 ndr_print_ptr(ndr, "handle", r->out.handle);
27575                 ndr->depth++;
27576                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27577                 ndr->depth--;
27578                 ndr_print_WERROR(ndr, "result", r->out.result);
27579                 ndr->depth--;
27580         }
27581         ndr->depth--;
27582 }
27583
27584 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27585 {
27586         if (flags & NDR_IN) {
27587         }
27588         if (flags & NDR_OUT) {
27589                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27590         }
27591         return NDR_ERR_SUCCESS;
27592 }
27593
27594 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27595 {
27596         if (flags & NDR_IN) {
27597         }
27598         if (flags & NDR_OUT) {
27599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27600         }
27601         return NDR_ERR_SUCCESS;
27602 }
27603
27604 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27605 {
27606         ndr_print_struct(ndr, name, "spoolss_47");
27607         ndr->depth++;
27608         if (flags & NDR_SET_VALUES) {
27609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27610         }
27611         if (flags & NDR_IN) {
27612                 ndr_print_struct(ndr, "in", "spoolss_47");
27613                 ndr->depth++;
27614                 ndr->depth--;
27615         }
27616         if (flags & NDR_OUT) {
27617                 ndr_print_struct(ndr, "out", "spoolss_47");
27618                 ndr->depth++;
27619                 ndr_print_WERROR(ndr, "result", r->out.result);
27620                 ndr->depth--;
27621         }
27622         ndr->depth--;
27623 }
27624
27625 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27626 {
27627         if (flags & NDR_IN) {
27628                 if (r->in.handle == NULL) {
27629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27630                 }
27631                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27635         }
27636         if (flags & NDR_OUT) {
27637                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27638                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27639                 if (r->out.value_needed == NULL) {
27640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27641                 }
27642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27643                 if (r->out.type == NULL) {
27644                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27645                 }
27646                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27647                 {
27648                         uint32_t _flags_save_uint8 = ndr->flags;
27649                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27650                         if (r->out.data == NULL) {
27651                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27652                         }
27653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27654                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27655                         ndr->flags = _flags_save_uint8;
27656                 }
27657                 if (r->out.data_needed == NULL) {
27658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27659                 }
27660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27661                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27662         }
27663         return NDR_ERR_SUCCESS;
27664 }
27665
27666 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27667 {
27668         TALLOC_CTX *_mem_save_handle_0;
27669         TALLOC_CTX *_mem_save_value_needed_0;
27670         TALLOC_CTX *_mem_save_type_0;
27671         TALLOC_CTX *_mem_save_data_needed_0;
27672         if (flags & NDR_IN) {
27673                 ZERO_STRUCT(r->out);
27674
27675                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27676                         NDR_PULL_ALLOC(ndr, r->in.handle);
27677                 }
27678                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27679                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27680                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27685                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27686                 ZERO_STRUCTP(r->out.value_needed);
27687                 NDR_PULL_ALLOC(ndr, r->out.type);
27688                 ZERO_STRUCTP(r->out.type);
27689                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27690                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27691                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27692                 ZERO_STRUCTP(r->out.data_needed);
27693         }
27694         if (flags & NDR_OUT) {
27695                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27696                 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));
27697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27698                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27699                 }
27700                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27705                         NDR_PULL_ALLOC(ndr, r->out.type);
27706                 }
27707                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27709                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27711                 {
27712                         uint32_t _flags_save_uint8 = ndr->flags;
27713                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27714                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27715                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27716                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27717                         }
27718                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27719                         ndr->flags = _flags_save_uint8;
27720                 }
27721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27722                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27723                 }
27724                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27725                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27728                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27729                 if (r->out.value_name) {
27730                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27731                 }
27732                 if (r->out.data) {
27733                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27734                 }
27735         }
27736         return NDR_ERR_SUCCESS;
27737 }
27738
27739 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27740 {
27741         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27742         ndr->depth++;
27743         if (flags & NDR_SET_VALUES) {
27744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27745         }
27746         if (flags & NDR_IN) {
27747                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27748                 ndr->depth++;
27749                 ndr_print_ptr(ndr, "handle", r->in.handle);
27750                 ndr->depth++;
27751                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27752                 ndr->depth--;
27753                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27754                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27755                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27756                 ndr->depth--;
27757         }
27758         if (flags & NDR_OUT) {
27759                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27760                 ndr->depth++;
27761                 ndr_print_string(ndr, "value_name", r->out.value_name);
27762                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27763                 ndr->depth++;
27764                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27765                 ndr->depth--;
27766                 ndr_print_ptr(ndr, "type", r->out.type);
27767                 ndr->depth++;
27768                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27769                 ndr->depth--;
27770                 ndr_print_ptr(ndr, "data", r->out.data);
27771                 ndr->depth++;
27772                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27773                 ndr->depth--;
27774                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27775                 ndr->depth++;
27776                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27777                 ndr->depth--;
27778                 ndr_print_WERROR(ndr, "result", r->out.result);
27779                 ndr->depth--;
27780         }
27781         ndr->depth--;
27782 }
27783
27784 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27785 {
27786         if (flags & NDR_IN) {
27787                 if (r->in.handle == NULL) {
27788                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27789                 }
27790                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27791                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27792                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27793                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27794                 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));
27795         }
27796         if (flags & NDR_OUT) {
27797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27798         }
27799         return NDR_ERR_SUCCESS;
27800 }
27801
27802 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27803 {
27804         TALLOC_CTX *_mem_save_handle_0;
27805         if (flags & NDR_IN) {
27806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27807                         NDR_PULL_ALLOC(ndr, r->in.handle);
27808                 }
27809                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27811                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27813                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27814                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27815                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27816                         return 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));
27817                 }
27818                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27819                 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));
27820         }
27821         if (flags & NDR_OUT) {
27822                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27823         }
27824         return NDR_ERR_SUCCESS;
27825 }
27826
27827 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27828 {
27829         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27830         ndr->depth++;
27831         if (flags & NDR_SET_VALUES) {
27832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27833         }
27834         if (flags & NDR_IN) {
27835                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27836                 ndr->depth++;
27837                 ndr_print_ptr(ndr, "handle", r->in.handle);
27838                 ndr->depth++;
27839                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27840                 ndr->depth--;
27841                 ndr_print_string(ndr, "value_name", r->in.value_name);
27842                 ndr->depth--;
27843         }
27844         if (flags & NDR_OUT) {
27845                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27846                 ndr->depth++;
27847                 ndr_print_WERROR(ndr, "result", r->out.result);
27848                 ndr->depth--;
27849         }
27850         ndr->depth--;
27851 }
27852
27853 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27854 {
27855         if (flags & NDR_IN) {
27856         }
27857         if (flags & NDR_OUT) {
27858                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27859         }
27860         return NDR_ERR_SUCCESS;
27861 }
27862
27863 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27864 {
27865         if (flags & NDR_IN) {
27866         }
27867         if (flags & NDR_OUT) {
27868                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27869         }
27870         return NDR_ERR_SUCCESS;
27871 }
27872
27873 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27874 {
27875         ndr_print_struct(ndr, name, "spoolss_4a");
27876         ndr->depth++;
27877         if (flags & NDR_SET_VALUES) {
27878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27879         }
27880         if (flags & NDR_IN) {
27881                 ndr_print_struct(ndr, "in", "spoolss_4a");
27882                 ndr->depth++;
27883                 ndr->depth--;
27884         }
27885         if (flags & NDR_OUT) {
27886                 ndr_print_struct(ndr, "out", "spoolss_4a");
27887                 ndr->depth++;
27888                 ndr_print_WERROR(ndr, "result", r->out.result);
27889                 ndr->depth--;
27890         }
27891         ndr->depth--;
27892 }
27893
27894 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27895 {
27896         if (flags & NDR_IN) {
27897         }
27898         if (flags & NDR_OUT) {
27899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27900         }
27901         return NDR_ERR_SUCCESS;
27902 }
27903
27904 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27905 {
27906         if (flags & NDR_IN) {
27907         }
27908         if (flags & NDR_OUT) {
27909                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27910         }
27911         return NDR_ERR_SUCCESS;
27912 }
27913
27914 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27915 {
27916         ndr_print_struct(ndr, name, "spoolss_4b");
27917         ndr->depth++;
27918         if (flags & NDR_SET_VALUES) {
27919                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27920         }
27921         if (flags & NDR_IN) {
27922                 ndr_print_struct(ndr, "in", "spoolss_4b");
27923                 ndr->depth++;
27924                 ndr->depth--;
27925         }
27926         if (flags & NDR_OUT) {
27927                 ndr_print_struct(ndr, "out", "spoolss_4b");
27928                 ndr->depth++;
27929                 ndr_print_WERROR(ndr, "result", r->out.result);
27930                 ndr->depth--;
27931         }
27932         ndr->depth--;
27933 }
27934
27935 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27936 {
27937         if (flags & NDR_IN) {
27938         }
27939         if (flags & NDR_OUT) {
27940                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27941         }
27942         return NDR_ERR_SUCCESS;
27943 }
27944
27945 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27946 {
27947         if (flags & NDR_IN) {
27948         }
27949         if (flags & NDR_OUT) {
27950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27951         }
27952         return NDR_ERR_SUCCESS;
27953 }
27954
27955 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27956 {
27957         ndr_print_struct(ndr, name, "spoolss_4c");
27958         ndr->depth++;
27959         if (flags & NDR_SET_VALUES) {
27960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27961         }
27962         if (flags & NDR_IN) {
27963                 ndr_print_struct(ndr, "in", "spoolss_4c");
27964                 ndr->depth++;
27965                 ndr->depth--;
27966         }
27967         if (flags & NDR_OUT) {
27968                 ndr_print_struct(ndr, "out", "spoolss_4c");
27969                 ndr->depth++;
27970                 ndr_print_WERROR(ndr, "result", r->out.result);
27971                 ndr->depth--;
27972         }
27973         ndr->depth--;
27974 }
27975
27976 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
27977 {
27978         if (flags & NDR_IN) {
27979                 if (r->in.handle == NULL) {
27980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27981                 }
27982                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27983                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27984                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27985                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27986                 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));
27987                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27988                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27989                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27990                 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));
27991                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27992                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
27993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
27994         }
27995         if (flags & NDR_OUT) {
27996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27997         }
27998         return NDR_ERR_SUCCESS;
27999 }
28000
28001 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
28002 {
28003         if (flags & NDR_IN) {
28004                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28005         }
28006         if (flags & NDR_OUT) {
28007                 if (r->out.data == NULL) {
28008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28009                 }
28010                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28011                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28012         }
28013         return NDR_ERR_SUCCESS;
28014 }
28015
28016 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28017 {
28018         TALLOC_CTX *_mem_save_handle_0;
28019         if (flags & NDR_IN) {
28020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28021                         NDR_PULL_ALLOC(ndr, r->in.handle);
28022                 }
28023                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28024                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28025                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28027                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28028                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28029                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28030                         return 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));
28031                 }
28032                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28033                 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));
28034                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28035                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28036                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28037                         return 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));
28038                 }
28039                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28040                 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));
28041                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28042                 {
28043                         struct ndr_pull *_ndr_data;
28044                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
28045                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
28046                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
28047                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
28048                 }
28049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
28050         }
28051         if (flags & NDR_OUT) {
28052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28053         }
28054         return NDR_ERR_SUCCESS;
28055 }
28056
28057 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28058 {
28059         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28060         ndr->depth++;
28061         if (flags & NDR_SET_VALUES) {
28062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28063         }
28064         if (flags & NDR_IN) {
28065                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28066                 ndr->depth++;
28067                 ndr_print_ptr(ndr, "handle", r->in.handle);
28068                 ndr->depth++;
28069                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28070                 ndr->depth--;
28071                 ndr_print_string(ndr, "key_name", r->in.key_name);
28072                 ndr_print_string(ndr, "value_name", r->in.value_name);
28073                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28074                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
28075                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
28076                 ndr_print_uint32(ndr, "_offered", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(&r->in.data, r->in.type, ndr->iconv_convenience, flags):r->in._offered);
28077                 ndr->depth--;
28078         }
28079         if (flags & NDR_OUT) {
28080                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28081                 ndr->depth++;
28082                 ndr_print_WERROR(ndr, "result", r->out.result);
28083                 ndr->depth--;
28084         }
28085         ndr->depth--;
28086 }
28087
28088 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
28089 {
28090         if (flags & NDR_IN) {
28091                 if (r->in.handle == NULL) {
28092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28093                 }
28094                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28095                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28096                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28098                 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));
28099                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28100                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28101                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28102                 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));
28103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28104         }
28105         if (flags & NDR_OUT) {
28106                 if (r->out.type == NULL) {
28107                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28108                 }
28109                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28110                 if (r->out.data == NULL) {
28111                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28112                 }
28113                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
28114                 if (r->out.needed == NULL) {
28115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28116                 }
28117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28119         }
28120         return NDR_ERR_SUCCESS;
28121 }
28122
28123 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
28124 {
28125         TALLOC_CTX *_mem_save_handle_0;
28126         TALLOC_CTX *_mem_save_type_0;
28127         TALLOC_CTX *_mem_save_data_0;
28128         TALLOC_CTX *_mem_save_needed_0;
28129         if (flags & NDR_IN) {
28130                 ZERO_STRUCT(r->out);
28131
28132                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28133                         NDR_PULL_ALLOC(ndr, r->in.handle);
28134                 }
28135                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28136                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28137                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28138                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28139                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28140                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28141                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28142                         return 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));
28143                 }
28144                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28145                 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));
28146                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28147                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28148                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28149                         return 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));
28150                 }
28151                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28152                 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));
28153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28154                 NDR_PULL_ALLOC(ndr, r->out.type);
28155                 ZERO_STRUCTP(r->out.type);
28156                 NDR_PULL_ALLOC(ndr, r->out.data);
28157                 ZERO_STRUCTP(r->out.data);
28158                 NDR_PULL_ALLOC(ndr, r->out.needed);
28159                 ZERO_STRUCTP(r->out.needed);
28160         }
28161         if (flags & NDR_OUT) {
28162                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28163                         NDR_PULL_ALLOC(ndr, r->out.type);
28164                 }
28165                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28166                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28167                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28169                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28170                         NDR_PULL_ALLOC(ndr, r->out.data);
28171                 }
28172                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28173                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28174                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
28175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28176                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28177                         NDR_PULL_ALLOC(ndr, r->out.needed);
28178                 }
28179                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28180                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28183                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28184         }
28185         return NDR_ERR_SUCCESS;
28186 }
28187
28188 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
28189 {
28190         if (flags & NDR_IN) {
28191                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28192         }
28193         if (flags & NDR_OUT) {
28194                 if (r->out.data == NULL) {
28195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28196                 }
28197                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28198                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28199         }
28200         return NDR_ERR_SUCCESS;
28201 }
28202
28203 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
28204 {
28205         TALLOC_CTX *_mem_save_data_0;
28206         if (flags & NDR_IN) {
28207                 ZERO_STRUCT(r->out);
28208
28209                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28210                 NDR_PULL_ALLOC(ndr, r->out.data);
28211                 ZERO_STRUCTP(r->out.data);
28212         }
28213         if (flags & NDR_OUT) {
28214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28215                         NDR_PULL_ALLOC(ndr, r->out.data);
28216                 }
28217                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28219                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28220                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28222         }
28223         return NDR_ERR_SUCCESS;
28224 }
28225
28226 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28227 {
28228         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28229         ndr->depth++;
28230         if (flags & NDR_SET_VALUES) {
28231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28232         }
28233         if (flags & NDR_IN) {
28234                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28235                 ndr->depth++;
28236                 ndr_print_ptr(ndr, "handle", r->in.handle);
28237                 ndr->depth++;
28238                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28239                 ndr->depth--;
28240                 ndr_print_string(ndr, "key_name", r->in.key_name);
28241                 ndr_print_string(ndr, "value_name", r->in.value_name);
28242                 ndr_print_uint32(ndr, "offered", r->in.offered);
28243                 ndr->depth--;
28244         }
28245         if (flags & NDR_OUT) {
28246                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28247                 ndr->depth++;
28248                 ndr_print_ptr(ndr, "type", r->out.type);
28249                 ndr->depth++;
28250                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28251                 ndr->depth--;
28252                 ndr_print_ptr(ndr, "data", r->out.data);
28253                 ndr->depth++;
28254                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28255                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28256                 ndr->depth--;
28257                 ndr_print_ptr(ndr, "needed", r->out.needed);
28258                 ndr->depth++;
28259                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28260                 ndr->depth--;
28261                 ndr_print_WERROR(ndr, "result", r->out.result);
28262                 ndr->depth--;
28263         }
28264         ndr->depth--;
28265 }
28266
28267 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28268 {
28269         if (flags & NDR_IN) {
28270                 if (r->in.handle == NULL) {
28271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28272                 }
28273                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28274                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28275                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28276                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28277                 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));
28278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28279         }
28280         if (flags & NDR_OUT) {
28281                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28282                 if (r->out.needed == NULL) {
28283                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28284                 }
28285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28286                 if (r->out.count == NULL) {
28287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28288                 }
28289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28290                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28291         }
28292         return NDR_ERR_SUCCESS;
28293 }
28294
28295 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28296 {
28297         TALLOC_CTX *_mem_save_handle_0;
28298         TALLOC_CTX *_mem_save_needed_0;
28299         TALLOC_CTX *_mem_save_count_0;
28300         if (flags & NDR_IN) {
28301                 ZERO_STRUCT(r->out);
28302
28303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28304                         NDR_PULL_ALLOC(ndr, r->in.handle);
28305                 }
28306                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28307                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28308                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28310                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28311                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28312                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28313                         return 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));
28314                 }
28315                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28316                 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));
28317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28318                 NDR_PULL_ALLOC(ndr, r->out.needed);
28319                 ZERO_STRUCTP(r->out.needed);
28320                 NDR_PULL_ALLOC(ndr, r->out.count);
28321                 ZERO_STRUCTP(r->out.count);
28322         }
28323         if (flags & NDR_OUT) {
28324                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28326                         NDR_PULL_ALLOC(ndr, r->out.needed);
28327                 }
28328                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28333                         NDR_PULL_ALLOC(ndr, r->out.count);
28334                 }
28335                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28336                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28339                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28340         }
28341         return NDR_ERR_SUCCESS;
28342 }
28343
28344 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28345 {
28346         uint32_t cntr_info_0;
28347         if (flags & NDR_IN) {
28348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28349         }
28350         if (flags & NDR_OUT) {
28351                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28352                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28353                 }
28354                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28355                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28356                 }
28357         }
28358         return NDR_ERR_SUCCESS;
28359 }
28360
28361 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28362 {
28363         uint32_t cntr_info_0;
28364         TALLOC_CTX *_mem_save_info_0;
28365         if (flags & NDR_IN) {
28366                 ZERO_STRUCT(r->out);
28367
28368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28369         }
28370         if (flags & NDR_OUT) {
28371                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28372                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28373                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28374                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28375                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28376                 }
28377                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28378                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28379                 }
28380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28381         }
28382         return NDR_ERR_SUCCESS;
28383 }
28384
28385 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28386 {
28387         uint32_t cntr_info_2;
28388         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28389         ndr->depth++;
28390         if (flags & NDR_SET_VALUES) {
28391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28392         }
28393         if (flags & NDR_IN) {
28394                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28395                 ndr->depth++;
28396                 ndr_print_ptr(ndr, "handle", r->in.handle);
28397                 ndr->depth++;
28398                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28399                 ndr->depth--;
28400                 ndr_print_string(ndr, "key_name", r->in.key_name);
28401                 ndr_print_uint32(ndr, "offered", r->in.offered);
28402                 ndr->depth--;
28403         }
28404         if (flags & NDR_OUT) {
28405                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28406                 ndr->depth++;
28407                 ndr_print_ptr(ndr, "count", r->out.count);
28408                 ndr->depth++;
28409                 ndr_print_uint32(ndr, "count", *r->out.count);
28410                 ndr->depth--;
28411                 ndr_print_ptr(ndr, "info", r->out.info);
28412                 ndr->depth++;
28413                 ndr_print_ptr(ndr, "info", *r->out.info);
28414                 ndr->depth++;
28415                 if (*r->out.info) {
28416                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28417                         ndr->depth++;
28418                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28419                                 char *idx_2=NULL;
28420                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28421                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28422                                         free(idx_2);
28423                                 }
28424                         }
28425                         ndr->depth--;
28426                 }
28427                 ndr->depth--;
28428                 ndr->depth--;
28429                 ndr_print_ptr(ndr, "needed", r->out.needed);
28430                 ndr->depth++;
28431                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28432                 ndr->depth--;
28433                 ndr_print_WERROR(ndr, "result", r->out.result);
28434                 ndr->depth--;
28435         }
28436         ndr->depth--;
28437 }
28438
28439 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28440 {
28441         if (flags & NDR_IN) {
28442                 if (r->in.handle == NULL) {
28443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28444                 }
28445                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28446                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28447                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28448                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28449                 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));
28450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28451         }
28452         if (flags & NDR_OUT) {
28453                 if (r->out._ndr_size == NULL) {
28454                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28455                 }
28456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28457                 if (r->out.key_buffer == NULL) {
28458                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28459                 }
28460                 {
28461                         struct ndr_push *_ndr_key_buffer;
28462                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28463                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28464                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28465                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28466                 }
28467                 if (r->out.needed == NULL) {
28468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28469                 }
28470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28472         }
28473         return NDR_ERR_SUCCESS;
28474 }
28475
28476 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28477 {
28478         TALLOC_CTX *_mem_save_handle_0;
28479         TALLOC_CTX *_mem_save__ndr_size_0;
28480         TALLOC_CTX *_mem_save_key_buffer_0;
28481         TALLOC_CTX *_mem_save_needed_0;
28482         if (flags & NDR_IN) {
28483                 ZERO_STRUCT(r->out);
28484
28485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28486                         NDR_PULL_ALLOC(ndr, r->in.handle);
28487                 }
28488                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28489                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28490                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28492                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28493                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28494                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28495                         return 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));
28496                 }
28497                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28498                 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));
28499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28500                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28501                 ZERO_STRUCTP(r->out._ndr_size);
28502                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28503                 ZERO_STRUCTP(r->out.key_buffer);
28504                 NDR_PULL_ALLOC(ndr, r->out.needed);
28505                 ZERO_STRUCTP(r->out.needed);
28506         }
28507         if (flags & NDR_OUT) {
28508                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28509                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28510                 }
28511                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28512                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28514                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28515                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28516                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28517                 }
28518                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28519                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28520                 {
28521                         struct ndr_pull *_ndr_key_buffer;
28522                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28523                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28524                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28525                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28526                 }
28527                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28528                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28529                         NDR_PULL_ALLOC(ndr, r->out.needed);
28530                 }
28531                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28532                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28534                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28535                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28536         }
28537         return NDR_ERR_SUCCESS;
28538 }
28539
28540 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28541 {
28542         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28543         ndr->depth++;
28544         if (flags & NDR_SET_VALUES) {
28545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28546         }
28547         if (flags & NDR_IN) {
28548                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28549                 ndr->depth++;
28550                 ndr_print_ptr(ndr, "handle", r->in.handle);
28551                 ndr->depth++;
28552                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28553                 ndr->depth--;
28554                 ndr_print_string(ndr, "key_name", r->in.key_name);
28555                 ndr_print_uint32(ndr, "offered", r->in.offered);
28556                 ndr->depth--;
28557         }
28558         if (flags & NDR_OUT) {
28559                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28560                 ndr->depth++;
28561                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28562                 ndr->depth++;
28563                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28564                 ndr->depth--;
28565                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28566                 ndr->depth++;
28567                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28568                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28569                 ndr->depth--;
28570                 ndr_print_ptr(ndr, "needed", r->out.needed);
28571                 ndr->depth++;
28572                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28573                 ndr->depth--;
28574                 ndr_print_WERROR(ndr, "result", r->out.result);
28575                 ndr->depth--;
28576         }
28577         ndr->depth--;
28578 }
28579
28580 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28581 {
28582         if (flags & NDR_IN) {
28583                 if (r->in.handle == NULL) {
28584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28585                 }
28586                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28587                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28590                 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));
28591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28592                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28593                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28594                 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));
28595         }
28596         if (flags & NDR_OUT) {
28597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28598         }
28599         return NDR_ERR_SUCCESS;
28600 }
28601
28602 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28603 {
28604         TALLOC_CTX *_mem_save_handle_0;
28605         if (flags & NDR_IN) {
28606                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28607                         NDR_PULL_ALLOC(ndr, r->in.handle);
28608                 }
28609                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28610                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28611                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28613                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28614                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28615                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28616                         return 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));
28617                 }
28618                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28619                 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));
28620                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28621                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28622                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28623                         return 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));
28624                 }
28625                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28626                 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));
28627         }
28628         if (flags & NDR_OUT) {
28629                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28630         }
28631         return NDR_ERR_SUCCESS;
28632 }
28633
28634 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28635 {
28636         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28637         ndr->depth++;
28638         if (flags & NDR_SET_VALUES) {
28639                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28640         }
28641         if (flags & NDR_IN) {
28642                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28643                 ndr->depth++;
28644                 ndr_print_ptr(ndr, "handle", r->in.handle);
28645                 ndr->depth++;
28646                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28647                 ndr->depth--;
28648                 ndr_print_string(ndr, "key_name", r->in.key_name);
28649                 ndr_print_string(ndr, "value_name", r->in.value_name);
28650                 ndr->depth--;
28651         }
28652         if (flags & NDR_OUT) {
28653                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28654                 ndr->depth++;
28655                 ndr_print_WERROR(ndr, "result", r->out.result);
28656                 ndr->depth--;
28657         }
28658         ndr->depth--;
28659 }
28660
28661 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28662 {
28663         if (flags & NDR_IN) {
28664                 if (r->in.handle == NULL) {
28665                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28666                 }
28667                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28668                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28669                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28670                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28671                 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));
28672         }
28673         if (flags & NDR_OUT) {
28674                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28675         }
28676         return NDR_ERR_SUCCESS;
28677 }
28678
28679 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28680 {
28681         TALLOC_CTX *_mem_save_handle_0;
28682         if (flags & NDR_IN) {
28683                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28684                         NDR_PULL_ALLOC(ndr, r->in.handle);
28685                 }
28686                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28687                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28688                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28690                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28691                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28692                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28693                         return 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));
28694                 }
28695                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28696                 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));
28697         }
28698         if (flags & NDR_OUT) {
28699                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28700         }
28701         return NDR_ERR_SUCCESS;
28702 }
28703
28704 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28705 {
28706         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28707         ndr->depth++;
28708         if (flags & NDR_SET_VALUES) {
28709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28710         }
28711         if (flags & NDR_IN) {
28712                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28713                 ndr->depth++;
28714                 ndr_print_ptr(ndr, "handle", r->in.handle);
28715                 ndr->depth++;
28716                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28717                 ndr->depth--;
28718                 ndr_print_string(ndr, "key_name", r->in.key_name);
28719                 ndr->depth--;
28720         }
28721         if (flags & NDR_OUT) {
28722                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28723                 ndr->depth++;
28724                 ndr_print_WERROR(ndr, "result", r->out.result);
28725                 ndr->depth--;
28726         }
28727         ndr->depth--;
28728 }
28729
28730 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28731 {
28732         if (flags & NDR_IN) {
28733         }
28734         if (flags & NDR_OUT) {
28735                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28736         }
28737         return NDR_ERR_SUCCESS;
28738 }
28739
28740 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28741 {
28742         if (flags & NDR_IN) {
28743         }
28744         if (flags & NDR_OUT) {
28745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28746         }
28747         return NDR_ERR_SUCCESS;
28748 }
28749
28750 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28751 {
28752         ndr_print_struct(ndr, name, "spoolss_53");
28753         ndr->depth++;
28754         if (flags & NDR_SET_VALUES) {
28755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28756         }
28757         if (flags & NDR_IN) {
28758                 ndr_print_struct(ndr, "in", "spoolss_53");
28759                 ndr->depth++;
28760                 ndr->depth--;
28761         }
28762         if (flags & NDR_OUT) {
28763                 ndr_print_struct(ndr, "out", "spoolss_53");
28764                 ndr->depth++;
28765                 ndr_print_WERROR(ndr, "result", r->out.result);
28766                 ndr->depth--;
28767         }
28768         ndr->depth--;
28769 }
28770
28771 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28772 {
28773         if (flags & NDR_IN) {
28774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28775                 if (r->in.server) {
28776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28780                 }
28781                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28782                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28783                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28784                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28785                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28786                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28787                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28788                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28789                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28791         }
28792         if (flags & NDR_OUT) {
28793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28794         }
28795         return NDR_ERR_SUCCESS;
28796 }
28797
28798 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28799 {
28800         uint32_t _ptr_server;
28801         TALLOC_CTX *_mem_save_server_0;
28802         if (flags & NDR_IN) {
28803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28804                 if (_ptr_server) {
28805                         NDR_PULL_ALLOC(ndr, r->in.server);
28806                 } else {
28807                         r->in.server = NULL;
28808                 }
28809                 if (r->in.server) {
28810                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28811                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28812                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28813                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28814                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28815                                 return 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));
28816                         }
28817                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28818                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28820                 }
28821                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28822                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28823                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28824                         return 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));
28825                 }
28826                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28827                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28828                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28829                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28830                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28831                         return 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));
28832                 }
28833                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28834                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28835                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28837         }
28838         if (flags & NDR_OUT) {
28839                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28840         }
28841         return NDR_ERR_SUCCESS;
28842 }
28843
28844 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28845 {
28846         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28847         ndr->depth++;
28848         if (flags & NDR_SET_VALUES) {
28849                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28850         }
28851         if (flags & NDR_IN) {
28852                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28853                 ndr->depth++;
28854                 ndr_print_ptr(ndr, "server", r->in.server);
28855                 ndr->depth++;
28856                 if (r->in.server) {
28857                         ndr_print_string(ndr, "server", r->in.server);
28858                 }
28859                 ndr->depth--;
28860                 ndr_print_string(ndr, "architecture", r->in.architecture);
28861                 ndr_print_string(ndr, "driver", r->in.driver);
28862                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28863                 ndr_print_uint32(ndr, "version", r->in.version);
28864                 ndr->depth--;
28865         }
28866         if (flags & NDR_OUT) {
28867                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28868                 ndr->depth++;
28869                 ndr_print_WERROR(ndr, "result", r->out.result);
28870                 ndr->depth--;
28871         }
28872         ndr->depth--;
28873 }
28874
28875 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28876 {
28877         if (flags & NDR_IN) {
28878         }
28879         if (flags & NDR_OUT) {
28880                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28881         }
28882         return NDR_ERR_SUCCESS;
28883 }
28884
28885 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28886 {
28887         if (flags & NDR_IN) {
28888         }
28889         if (flags & NDR_OUT) {
28890                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28891         }
28892         return NDR_ERR_SUCCESS;
28893 }
28894
28895 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28896 {
28897         ndr_print_struct(ndr, name, "spoolss_55");
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_55");
28904                 ndr->depth++;
28905                 ndr->depth--;
28906         }
28907         if (flags & NDR_OUT) {
28908                 ndr_print_struct(ndr, "out", "spoolss_55");
28909                 ndr->depth++;
28910                 ndr_print_WERROR(ndr, "result", r->out.result);
28911                 ndr->depth--;
28912         }
28913         ndr->depth--;
28914 }
28915
28916 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28917 {
28918         if (flags & NDR_IN) {
28919         }
28920         if (flags & NDR_OUT) {
28921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28922         }
28923         return NDR_ERR_SUCCESS;
28924 }
28925
28926 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28927 {
28928         if (flags & NDR_IN) {
28929         }
28930         if (flags & NDR_OUT) {
28931                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28932         }
28933         return NDR_ERR_SUCCESS;
28934 }
28935
28936 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28937 {
28938         ndr_print_struct(ndr, name, "spoolss_56");
28939         ndr->depth++;
28940         if (flags & NDR_SET_VALUES) {
28941                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28942         }
28943         if (flags & NDR_IN) {
28944                 ndr_print_struct(ndr, "in", "spoolss_56");
28945                 ndr->depth++;
28946                 ndr->depth--;
28947         }
28948         if (flags & NDR_OUT) {
28949                 ndr_print_struct(ndr, "out", "spoolss_56");
28950                 ndr->depth++;
28951                 ndr_print_WERROR(ndr, "result", r->out.result);
28952                 ndr->depth--;
28953         }
28954         ndr->depth--;
28955 }
28956
28957 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28958 {
28959         if (flags & NDR_IN) {
28960         }
28961         if (flags & NDR_OUT) {
28962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28963         }
28964         return NDR_ERR_SUCCESS;
28965 }
28966
28967 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28968 {
28969         if (flags & NDR_IN) {
28970         }
28971         if (flags & NDR_OUT) {
28972                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28973         }
28974         return NDR_ERR_SUCCESS;
28975 }
28976
28977 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28978 {
28979         ndr_print_struct(ndr, name, "spoolss_57");
28980         ndr->depth++;
28981         if (flags & NDR_SET_VALUES) {
28982                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28983         }
28984         if (flags & NDR_IN) {
28985                 ndr_print_struct(ndr, "in", "spoolss_57");
28986                 ndr->depth++;
28987                 ndr->depth--;
28988         }
28989         if (flags & NDR_OUT) {
28990                 ndr_print_struct(ndr, "out", "spoolss_57");
28991                 ndr->depth++;
28992                 ndr_print_WERROR(ndr, "result", r->out.result);
28993                 ndr->depth--;
28994         }
28995         ndr->depth--;
28996 }
28997
28998 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
28999 {
29000         if (flags & NDR_IN) {
29001                 if (r->in.handle == NULL) {
29002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29003                 }
29004                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29005                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29006                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29007                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29008                 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));
29009                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29012                 if (r->in.status_code == NULL) {
29013                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29014                 }
29015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29016         }
29017         if (flags & NDR_OUT) {
29018                 if (r->out.out_data == NULL) {
29019                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29020                 }
29021                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29022                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29023                 if (r->out.needed == NULL) {
29024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29025                 }
29026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29027                 if (r->out.status_code == NULL) {
29028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29029                 }
29030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29032         }
29033         return NDR_ERR_SUCCESS;
29034 }
29035
29036 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29037 {
29038         TALLOC_CTX *_mem_save_handle_0;
29039         TALLOC_CTX *_mem_save_needed_0;
29040         TALLOC_CTX *_mem_save_status_code_0;
29041         if (flags & NDR_IN) {
29042                 ZERO_STRUCT(r->out);
29043
29044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29045                         NDR_PULL_ALLOC(ndr, r->in.handle);
29046                 }
29047                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29048                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29049                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29051                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29052                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29053                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29054                         return 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));
29055                 }
29056                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29057                 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));
29058                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29062                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29063                 }
29064                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29065                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29068                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29069                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29070                 NDR_PULL_ALLOC(ndr, r->out.needed);
29071                 ZERO_STRUCTP(r->out.needed);
29072                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29073                 *r->out.status_code = *r->in.status_code;
29074         }
29075         if (flags & NDR_OUT) {
29076                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29077                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29078                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29079                 }
29080                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29082                         NDR_PULL_ALLOC(ndr, r->out.needed);
29083                 }
29084                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29085                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29087                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29089                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29090                 }
29091                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29092                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29095                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29096                 if (r->out.out_data) {
29097                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29098                 }
29099         }
29100         return NDR_ERR_SUCCESS;
29101 }
29102
29103 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29104 {
29105         ndr_print_struct(ndr, name, "spoolss_XcvData");
29106         ndr->depth++;
29107         if (flags & NDR_SET_VALUES) {
29108                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29109         }
29110         if (flags & NDR_IN) {
29111                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29112                 ndr->depth++;
29113                 ndr_print_ptr(ndr, "handle", r->in.handle);
29114                 ndr->depth++;
29115                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29116                 ndr->depth--;
29117                 ndr_print_string(ndr, "function_name", r->in.function_name);
29118                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29119                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29120                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29121                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29122                 ndr->depth++;
29123                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29124                 ndr->depth--;
29125                 ndr->depth--;
29126         }
29127         if (flags & NDR_OUT) {
29128                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29129                 ndr->depth++;
29130                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29131                 ndr->depth++;
29132                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29133                 ndr->depth--;
29134                 ndr_print_ptr(ndr, "needed", r->out.needed);
29135                 ndr->depth++;
29136                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29137                 ndr->depth--;
29138                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29139                 ndr->depth++;
29140                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29141                 ndr->depth--;
29142                 ndr_print_WERROR(ndr, "result", r->out.result);
29143                 ndr->depth--;
29144         }
29145         ndr->depth--;
29146 }
29147
29148 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29149 {
29150         if (flags & NDR_IN) {
29151                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29152                 if (r->in.servername) {
29153                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29154                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29157                 }
29158                 if (r->in.info_ctr == NULL) {
29159                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29160                 }
29161                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29162                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29163         }
29164         if (flags & NDR_OUT) {
29165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29166         }
29167         return NDR_ERR_SUCCESS;
29168 }
29169
29170 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29171 {
29172         uint32_t _ptr_servername;
29173         TALLOC_CTX *_mem_save_servername_0;
29174         TALLOC_CTX *_mem_save_info_ctr_0;
29175         if (flags & NDR_IN) {
29176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29177                 if (_ptr_servername) {
29178                         NDR_PULL_ALLOC(ndr, r->in.servername);
29179                 } else {
29180                         r->in.servername = NULL;
29181                 }
29182                 if (r->in.servername) {
29183                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29184                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29187                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29188                                 return 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));
29189                         }
29190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29193                 }
29194                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29195                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29196                 }
29197                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29198                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29199                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29200                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29201                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29202         }
29203         if (flags & NDR_OUT) {
29204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29205         }
29206         return NDR_ERR_SUCCESS;
29207 }
29208
29209 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29210 {
29211         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29212         ndr->depth++;
29213         if (flags & NDR_SET_VALUES) {
29214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29215         }
29216         if (flags & NDR_IN) {
29217                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29218                 ndr->depth++;
29219                 ndr_print_ptr(ndr, "servername", r->in.servername);
29220                 ndr->depth++;
29221                 if (r->in.servername) {
29222                         ndr_print_string(ndr, "servername", r->in.servername);
29223                 }
29224                 ndr->depth--;
29225                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29226                 ndr->depth++;
29227                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29228                 ndr->depth--;
29229                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29230                 ndr->depth--;
29231         }
29232         if (flags & NDR_OUT) {
29233                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29234                 ndr->depth++;
29235                 ndr_print_WERROR(ndr, "result", r->out.result);
29236                 ndr->depth--;
29237         }
29238         ndr->depth--;
29239 }
29240
29241 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29242 {
29243         if (flags & NDR_IN) {
29244         }
29245         if (flags & NDR_OUT) {
29246                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29247         }
29248         return NDR_ERR_SUCCESS;
29249 }
29250
29251 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29252 {
29253         if (flags & NDR_IN) {
29254         }
29255         if (flags & NDR_OUT) {
29256                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29257         }
29258         return NDR_ERR_SUCCESS;
29259 }
29260
29261 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29262 {
29263         ndr_print_struct(ndr, name, "spoolss_5a");
29264         ndr->depth++;
29265         if (flags & NDR_SET_VALUES) {
29266                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29267         }
29268         if (flags & NDR_IN) {
29269                 ndr_print_struct(ndr, "in", "spoolss_5a");
29270                 ndr->depth++;
29271                 ndr->depth--;
29272         }
29273         if (flags & NDR_OUT) {
29274                 ndr_print_struct(ndr, "out", "spoolss_5a");
29275                 ndr->depth++;
29276                 ndr_print_WERROR(ndr, "result", r->out.result);
29277                 ndr->depth--;
29278         }
29279         ndr->depth--;
29280 }
29281
29282 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29283 {
29284         if (flags & NDR_IN) {
29285         }
29286         if (flags & NDR_OUT) {
29287                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29288         }
29289         return NDR_ERR_SUCCESS;
29290 }
29291
29292 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29293 {
29294         if (flags & NDR_IN) {
29295         }
29296         if (flags & NDR_OUT) {
29297                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29298         }
29299         return NDR_ERR_SUCCESS;
29300 }
29301
29302 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29303 {
29304         ndr_print_struct(ndr, name, "spoolss_5b");
29305         ndr->depth++;
29306         if (flags & NDR_SET_VALUES) {
29307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29308         }
29309         if (flags & NDR_IN) {
29310                 ndr_print_struct(ndr, "in", "spoolss_5b");
29311                 ndr->depth++;
29312                 ndr->depth--;
29313         }
29314         if (flags & NDR_OUT) {
29315                 ndr_print_struct(ndr, "out", "spoolss_5b");
29316                 ndr->depth++;
29317                 ndr_print_WERROR(ndr, "result", r->out.result);
29318                 ndr->depth--;
29319         }
29320         ndr->depth--;
29321 }
29322
29323 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29324 {
29325         if (flags & NDR_IN) {
29326         }
29327         if (flags & NDR_OUT) {
29328                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29329         }
29330         return NDR_ERR_SUCCESS;
29331 }
29332
29333 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29334 {
29335         if (flags & NDR_IN) {
29336         }
29337         if (flags & NDR_OUT) {
29338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29339         }
29340         return NDR_ERR_SUCCESS;
29341 }
29342
29343 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29344 {
29345         ndr_print_struct(ndr, name, "spoolss_5c");
29346         ndr->depth++;
29347         if (flags & NDR_SET_VALUES) {
29348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29349         }
29350         if (flags & NDR_IN) {
29351                 ndr_print_struct(ndr, "in", "spoolss_5c");
29352                 ndr->depth++;
29353                 ndr->depth--;
29354         }
29355         if (flags & NDR_OUT) {
29356                 ndr_print_struct(ndr, "out", "spoolss_5c");
29357                 ndr->depth++;
29358                 ndr_print_WERROR(ndr, "result", r->out.result);
29359                 ndr->depth--;
29360         }
29361         ndr->depth--;
29362 }
29363
29364 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29365 {
29366         if (flags & NDR_IN) {
29367         }
29368         if (flags & NDR_OUT) {
29369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29370         }
29371         return NDR_ERR_SUCCESS;
29372 }
29373
29374 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29375 {
29376         if (flags & NDR_IN) {
29377         }
29378         if (flags & NDR_OUT) {
29379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29380         }
29381         return NDR_ERR_SUCCESS;
29382 }
29383
29384 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29385 {
29386         ndr_print_struct(ndr, name, "spoolss_5d");
29387         ndr->depth++;
29388         if (flags & NDR_SET_VALUES) {
29389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29390         }
29391         if (flags & NDR_IN) {
29392                 ndr_print_struct(ndr, "in", "spoolss_5d");
29393                 ndr->depth++;
29394                 ndr->depth--;
29395         }
29396         if (flags & NDR_OUT) {
29397                 ndr_print_struct(ndr, "out", "spoolss_5d");
29398                 ndr->depth++;
29399                 ndr_print_WERROR(ndr, "result", r->out.result);
29400                 ndr->depth--;
29401         }
29402         ndr->depth--;
29403 }
29404
29405 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29406 {
29407         if (flags & NDR_IN) {
29408         }
29409         if (flags & NDR_OUT) {
29410                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29411         }
29412         return NDR_ERR_SUCCESS;
29413 }
29414
29415 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29416 {
29417         if (flags & NDR_IN) {
29418         }
29419         if (flags & NDR_OUT) {
29420                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29421         }
29422         return NDR_ERR_SUCCESS;
29423 }
29424
29425 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29426 {
29427         ndr_print_struct(ndr, name, "spoolss_5e");
29428         ndr->depth++;
29429         if (flags & NDR_SET_VALUES) {
29430                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29431         }
29432         if (flags & NDR_IN) {
29433                 ndr_print_struct(ndr, "in", "spoolss_5e");
29434                 ndr->depth++;
29435                 ndr->depth--;
29436         }
29437         if (flags & NDR_OUT) {
29438                 ndr_print_struct(ndr, "out", "spoolss_5e");
29439                 ndr->depth++;
29440                 ndr_print_WERROR(ndr, "result", r->out.result);
29441                 ndr->depth--;
29442         }
29443         ndr->depth--;
29444 }
29445
29446 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29447 {
29448         if (flags & NDR_IN) {
29449         }
29450         if (flags & NDR_OUT) {
29451                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29452         }
29453         return NDR_ERR_SUCCESS;
29454 }
29455
29456 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29457 {
29458         if (flags & NDR_IN) {
29459         }
29460         if (flags & NDR_OUT) {
29461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29462         }
29463         return NDR_ERR_SUCCESS;
29464 }
29465
29466 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29467 {
29468         ndr_print_struct(ndr, name, "spoolss_5f");
29469         ndr->depth++;
29470         if (flags & NDR_SET_VALUES) {
29471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29472         }
29473         if (flags & NDR_IN) {
29474                 ndr_print_struct(ndr, "in", "spoolss_5f");
29475                 ndr->depth++;
29476                 ndr->depth--;
29477         }
29478         if (flags & NDR_OUT) {
29479                 ndr_print_struct(ndr, "out", "spoolss_5f");
29480                 ndr->depth++;
29481                 ndr_print_WERROR(ndr, "result", r->out.result);
29482                 ndr->depth--;
29483         }
29484         ndr->depth--;
29485 }
29486
29487 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29488 {
29489         if (flags & NDR_IN) {
29490         }
29491         if (flags & NDR_OUT) {
29492                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29493         }
29494         return NDR_ERR_SUCCESS;
29495 }
29496
29497 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29498 {
29499         if (flags & NDR_IN) {
29500         }
29501         if (flags & NDR_OUT) {
29502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29503         }
29504         return NDR_ERR_SUCCESS;
29505 }
29506
29507 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29508 {
29509         ndr_print_struct(ndr, name, "spoolss_60");
29510         ndr->depth++;
29511         if (flags & NDR_SET_VALUES) {
29512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29513         }
29514         if (flags & NDR_IN) {
29515                 ndr_print_struct(ndr, "in", "spoolss_60");
29516                 ndr->depth++;
29517                 ndr->depth--;
29518         }
29519         if (flags & NDR_OUT) {
29520                 ndr_print_struct(ndr, "out", "spoolss_60");
29521                 ndr->depth++;
29522                 ndr_print_WERROR(ndr, "result", r->out.result);
29523                 ndr->depth--;
29524         }
29525         ndr->depth--;
29526 }
29527
29528 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29529 {
29530         if (flags & NDR_IN) {
29531         }
29532         if (flags & NDR_OUT) {
29533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29534         }
29535         return NDR_ERR_SUCCESS;
29536 }
29537
29538 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29539 {
29540         if (flags & NDR_IN) {
29541         }
29542         if (flags & NDR_OUT) {
29543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29544         }
29545         return NDR_ERR_SUCCESS;
29546 }
29547
29548 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29549 {
29550         ndr_print_struct(ndr, name, "spoolss_61");
29551         ndr->depth++;
29552         if (flags & NDR_SET_VALUES) {
29553                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29554         }
29555         if (flags & NDR_IN) {
29556                 ndr_print_struct(ndr, "in", "spoolss_61");
29557                 ndr->depth++;
29558                 ndr->depth--;
29559         }
29560         if (flags & NDR_OUT) {
29561                 ndr_print_struct(ndr, "out", "spoolss_61");
29562                 ndr->depth++;
29563                 ndr_print_WERROR(ndr, "result", r->out.result);
29564                 ndr->depth--;
29565         }
29566         ndr->depth--;
29567 }
29568
29569 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29570 {
29571         if (flags & NDR_IN) {
29572         }
29573         if (flags & NDR_OUT) {
29574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29575         }
29576         return NDR_ERR_SUCCESS;
29577 }
29578
29579 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29580 {
29581         if (flags & NDR_IN) {
29582         }
29583         if (flags & NDR_OUT) {
29584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29585         }
29586         return NDR_ERR_SUCCESS;
29587 }
29588
29589 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29590 {
29591         ndr_print_struct(ndr, name, "spoolss_62");
29592         ndr->depth++;
29593         if (flags & NDR_SET_VALUES) {
29594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29595         }
29596         if (flags & NDR_IN) {
29597                 ndr_print_struct(ndr, "in", "spoolss_62");
29598                 ndr->depth++;
29599                 ndr->depth--;
29600         }
29601         if (flags & NDR_OUT) {
29602                 ndr_print_struct(ndr, "out", "spoolss_62");
29603                 ndr->depth++;
29604                 ndr_print_WERROR(ndr, "result", r->out.result);
29605                 ndr->depth--;
29606         }
29607         ndr->depth--;
29608 }
29609
29610 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29611 {
29612         if (flags & NDR_IN) {
29613         }
29614         if (flags & NDR_OUT) {
29615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29616         }
29617         return NDR_ERR_SUCCESS;
29618 }
29619
29620 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29621 {
29622         if (flags & NDR_IN) {
29623         }
29624         if (flags & NDR_OUT) {
29625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29626         }
29627         return NDR_ERR_SUCCESS;
29628 }
29629
29630 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29631 {
29632         ndr_print_struct(ndr, name, "spoolss_63");
29633         ndr->depth++;
29634         if (flags & NDR_SET_VALUES) {
29635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29636         }
29637         if (flags & NDR_IN) {
29638                 ndr_print_struct(ndr, "in", "spoolss_63");
29639                 ndr->depth++;
29640                 ndr->depth--;
29641         }
29642         if (flags & NDR_OUT) {
29643                 ndr_print_struct(ndr, "out", "spoolss_63");
29644                 ndr->depth++;
29645                 ndr_print_WERROR(ndr, "result", r->out.result);
29646                 ndr->depth--;
29647         }
29648         ndr->depth--;
29649 }
29650
29651 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29652 {
29653         if (flags & NDR_IN) {
29654         }
29655         if (flags & NDR_OUT) {
29656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29657         }
29658         return NDR_ERR_SUCCESS;
29659 }
29660
29661 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29662 {
29663         if (flags & NDR_IN) {
29664         }
29665         if (flags & NDR_OUT) {
29666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29667         }
29668         return NDR_ERR_SUCCESS;
29669 }
29670
29671 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29672 {
29673         ndr_print_struct(ndr, name, "spoolss_64");
29674         ndr->depth++;
29675         if (flags & NDR_SET_VALUES) {
29676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29677         }
29678         if (flags & NDR_IN) {
29679                 ndr_print_struct(ndr, "in", "spoolss_64");
29680                 ndr->depth++;
29681                 ndr->depth--;
29682         }
29683         if (flags & NDR_OUT) {
29684                 ndr_print_struct(ndr, "out", "spoolss_64");
29685                 ndr->depth++;
29686                 ndr_print_WERROR(ndr, "result", r->out.result);
29687                 ndr->depth--;
29688         }
29689         ndr->depth--;
29690 }
29691
29692 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29693 {
29694         if (flags & NDR_IN) {
29695         }
29696         if (flags & NDR_OUT) {
29697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29698         }
29699         return NDR_ERR_SUCCESS;
29700 }
29701
29702 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29703 {
29704         if (flags & NDR_IN) {
29705         }
29706         if (flags & NDR_OUT) {
29707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29708         }
29709         return NDR_ERR_SUCCESS;
29710 }
29711
29712 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29713 {
29714         ndr_print_struct(ndr, name, "spoolss_65");
29715         ndr->depth++;
29716         if (flags & NDR_SET_VALUES) {
29717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29718         }
29719         if (flags & NDR_IN) {
29720                 ndr_print_struct(ndr, "in", "spoolss_65");
29721                 ndr->depth++;
29722                 ndr->depth--;
29723         }
29724         if (flags & NDR_OUT) {
29725                 ndr_print_struct(ndr, "out", "spoolss_65");
29726                 ndr->depth++;
29727                 ndr_print_WERROR(ndr, "result", r->out.result);
29728                 ndr->depth--;
29729         }
29730         ndr->depth--;
29731 }
29732
29733 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29734 {
29735         uint32_t cntr_core_printer_drivers_1;
29736         if (flags & NDR_IN) {
29737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29738                 if (r->in.servername) {
29739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29743                 }
29744                 if (r->in.architecture == NULL) {
29745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29746                 }
29747                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29748                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29749                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29750                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29752                 if (r->in.core_driver_dependencies == NULL) {
29753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29754                 }
29755                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29756                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29758         }
29759         if (flags & NDR_OUT) {
29760                 if (r->out.core_printer_drivers == NULL) {
29761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29762                 }
29763                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29764                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29765                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29766                 }
29767                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29768         }
29769         return NDR_ERR_SUCCESS;
29770 }
29771
29772 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29773 {
29774         uint32_t _ptr_servername;
29775         uint32_t cntr_core_printer_drivers_1;
29776         TALLOC_CTX *_mem_save_servername_0;
29777         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29778         if (flags & NDR_IN) {
29779                 ZERO_STRUCT(r->out);
29780
29781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29782                 if (_ptr_servername) {
29783                         NDR_PULL_ALLOC(ndr, r->in.servername);
29784                 } else {
29785                         r->in.servername = NULL;
29786                 }
29787                 if (r->in.servername) {
29788                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29789                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29792                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29793                                 return 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));
29794                         }
29795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29798                 }
29799                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29800                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29801                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29802                         return 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));
29803                 }
29804                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29805                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29807                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29808                 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));
29809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29810                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29811                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29812                 if (r->in.core_driver_dependencies) {
29813                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29814                 }
29815         }
29816         if (flags & NDR_OUT) {
29817                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29819                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29820                 }
29821                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29822                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29823                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29824                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29825                 }
29826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29827                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29828                 if (r->out.core_printer_drivers) {
29829                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29830                 }
29831         }
29832         return NDR_ERR_SUCCESS;
29833 }
29834
29835 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29836 {
29837         uint32_t cntr_core_printer_drivers_1;
29838         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29839         ndr->depth++;
29840         if (flags & NDR_SET_VALUES) {
29841                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29842         }
29843         if (flags & NDR_IN) {
29844                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29845                 ndr->depth++;
29846                 ndr_print_ptr(ndr, "servername", r->in.servername);
29847                 ndr->depth++;
29848                 if (r->in.servername) {
29849                         ndr_print_string(ndr, "servername", r->in.servername);
29850                 }
29851                 ndr->depth--;
29852                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29853                 ndr->depth++;
29854                 ndr_print_string(ndr, "architecture", r->in.architecture);
29855                 ndr->depth--;
29856                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29857                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29858                 ndr->depth++;
29859                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29860                 ndr->depth--;
29861                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29862                 ndr->depth--;
29863         }
29864         if (flags & NDR_OUT) {
29865                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29866                 ndr->depth++;
29867                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29868                 ndr->depth++;
29869                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29870                 ndr->depth++;
29871                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29872                         char *idx_1=NULL;
29873                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29874                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29875                                 free(idx_1);
29876                         }
29877                 }
29878                 ndr->depth--;
29879                 ndr->depth--;
29880                 ndr_print_WERROR(ndr, "result", r->out.result);
29881                 ndr->depth--;
29882         }
29883         ndr->depth--;
29884 }
29885
29886 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29887 {
29888         if (flags & NDR_IN) {
29889         }
29890         if (flags & NDR_OUT) {
29891                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29892         }
29893         return NDR_ERR_SUCCESS;
29894 }
29895
29896 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29897 {
29898         if (flags & NDR_IN) {
29899         }
29900         if (flags & NDR_OUT) {
29901                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29902         }
29903         return NDR_ERR_SUCCESS;
29904 }
29905
29906 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29907 {
29908         ndr_print_struct(ndr, name, "spoolss_67");
29909         ndr->depth++;
29910         if (flags & NDR_SET_VALUES) {
29911                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29912         }
29913         if (flags & NDR_IN) {
29914                 ndr_print_struct(ndr, "in", "spoolss_67");
29915                 ndr->depth++;
29916                 ndr->depth--;
29917         }
29918         if (flags & NDR_OUT) {
29919                 ndr_print_struct(ndr, "out", "spoolss_67");
29920                 ndr->depth++;
29921                 ndr_print_WERROR(ndr, "result", r->out.result);
29922                 ndr->depth--;
29923         }
29924         ndr->depth--;
29925 }
29926
29927 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29928 {
29929         if (flags & NDR_IN) {
29930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29931                 if (r->in.servername) {
29932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29935                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29936                 }
29937                 if (r->in.architecture == NULL) {
29938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29939                 }
29940                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29941                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29942                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29943                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29945                 if (r->in.language) {
29946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29949                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29950                 }
29951                 if (r->in.package_id == NULL) {
29952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29953                 }
29954                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29955                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29956                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29957                 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));
29958                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29959                 if (r->in.driver_package_cab) {
29960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29962                 }
29963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29964         }
29965         if (flags & NDR_OUT) {
29966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29967                 if (r->out.driver_package_cab) {
29968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29970                 }
29971                 if (r->out.required == NULL) {
29972                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29973                 }
29974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29975                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29976         }
29977         return NDR_ERR_SUCCESS;
29978 }
29979
29980 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29981 {
29982         uint32_t _ptr_servername;
29983         uint32_t _ptr_language;
29984         uint32_t _ptr_driver_package_cab;
29985         TALLOC_CTX *_mem_save_servername_0;
29986         TALLOC_CTX *_mem_save_language_0;
29987         TALLOC_CTX *_mem_save_driver_package_cab_0;
29988         TALLOC_CTX *_mem_save_required_0;
29989         if (flags & NDR_IN) {
29990                 ZERO_STRUCT(r->out);
29991
29992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29993                 if (_ptr_servername) {
29994                         NDR_PULL_ALLOC(ndr, r->in.servername);
29995                 } else {
29996                         r->in.servername = NULL;
29997                 }
29998                 if (r->in.servername) {
29999                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30000                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30001                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30002                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30003                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30004                                 return 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));
30005                         }
30006                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30007                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30008                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30009                 }
30010                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30011                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30012                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30013                         return 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));
30014                 }
30015                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30016                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30018                 if (_ptr_language) {
30019                         NDR_PULL_ALLOC(ndr, r->in.language);
30020                 } else {
30021                         r->in.language = NULL;
30022                 }
30023                 if (r->in.language) {
30024                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30025                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30026                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30027                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30028                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30029                                 return 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));
30030                         }
30031                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30032                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30034                 }
30035                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30036                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30037                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30038                         return 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));
30039                 }
30040                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30041                 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));
30042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30043                 if (_ptr_driver_package_cab) {
30044                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30045                 } else {
30046                         r->in.driver_package_cab = NULL;
30047                 }
30048                 if (r->in.driver_package_cab) {
30049                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30050                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30051                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30052                         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));
30053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30054                 }
30055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30056                 NDR_PULL_ALLOC(ndr, r->out.required);
30057                 ZERO_STRUCTP(r->out.required);
30058                 if (r->in.driver_package_cab) {
30059                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30060                 }
30061         }
30062         if (flags & NDR_OUT) {
30063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30064                 if (_ptr_driver_package_cab) {
30065                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30066                 } else {
30067                         r->out.driver_package_cab = NULL;
30068                 }
30069                 if (r->out.driver_package_cab) {
30070                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30071                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30073                         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));
30074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30075                 }
30076                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30077                         NDR_PULL_ALLOC(ndr, r->out.required);
30078                 }
30079                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30080                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30082                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30084                 if (r->out.driver_package_cab) {
30085                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30086                 }
30087         }
30088         return NDR_ERR_SUCCESS;
30089 }
30090
30091 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30092 {
30093         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30094         ndr->depth++;
30095         if (flags & NDR_SET_VALUES) {
30096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30097         }
30098         if (flags & NDR_IN) {
30099                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30100                 ndr->depth++;
30101                 ndr_print_ptr(ndr, "servername", r->in.servername);
30102                 ndr->depth++;
30103                 if (r->in.servername) {
30104                         ndr_print_string(ndr, "servername", r->in.servername);
30105                 }
30106                 ndr->depth--;
30107                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30108                 ndr->depth++;
30109                 ndr_print_string(ndr, "architecture", r->in.architecture);
30110                 ndr->depth--;
30111                 ndr_print_ptr(ndr, "language", r->in.language);
30112                 ndr->depth++;
30113                 if (r->in.language) {
30114                         ndr_print_string(ndr, "language", r->in.language);
30115                 }
30116                 ndr->depth--;
30117                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30118                 ndr->depth++;
30119                 ndr_print_string(ndr, "package_id", r->in.package_id);
30120                 ndr->depth--;
30121                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30122                 ndr->depth++;
30123                 if (r->in.driver_package_cab) {
30124                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30125                 }
30126                 ndr->depth--;
30127                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30128                 ndr->depth--;
30129         }
30130         if (flags & NDR_OUT) {
30131                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30132                 ndr->depth++;
30133                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30134                 ndr->depth++;
30135                 if (r->out.driver_package_cab) {
30136                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30137                 }
30138                 ndr->depth--;
30139                 ndr_print_ptr(ndr, "required", r->out.required);
30140                 ndr->depth++;
30141                 ndr_print_uint32(ndr, "required", *r->out.required);
30142                 ndr->depth--;
30143                 ndr_print_WERROR(ndr, "result", r->out.result);
30144                 ndr->depth--;
30145         }
30146         ndr->depth--;
30147 }
30148
30149 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30150 {
30151         if (flags & NDR_IN) {
30152         }
30153         if (flags & NDR_OUT) {
30154                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30155         }
30156         return NDR_ERR_SUCCESS;
30157 }
30158
30159 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30160 {
30161         if (flags & NDR_IN) {
30162         }
30163         if (flags & NDR_OUT) {
30164                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30165         }
30166         return NDR_ERR_SUCCESS;
30167 }
30168
30169 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30170 {
30171         ndr_print_struct(ndr, name, "spoolss_69");
30172         ndr->depth++;
30173         if (flags & NDR_SET_VALUES) {
30174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30175         }
30176         if (flags & NDR_IN) {
30177                 ndr_print_struct(ndr, "in", "spoolss_69");
30178                 ndr->depth++;
30179                 ndr->depth--;
30180         }
30181         if (flags & NDR_OUT) {
30182                 ndr_print_struct(ndr, "out", "spoolss_69");
30183                 ndr->depth++;
30184                 ndr_print_WERROR(ndr, "result", r->out.result);
30185                 ndr->depth--;
30186         }
30187         ndr->depth--;
30188 }
30189
30190 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30191 {
30192         if (flags & NDR_IN) {
30193         }
30194         if (flags & NDR_OUT) {
30195                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30196         }
30197         return NDR_ERR_SUCCESS;
30198 }
30199
30200 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30201 {
30202         if (flags & NDR_IN) {
30203         }
30204         if (flags & NDR_OUT) {
30205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30206         }
30207         return NDR_ERR_SUCCESS;
30208 }
30209
30210 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30211 {
30212         ndr_print_struct(ndr, name, "spoolss_6a");
30213         ndr->depth++;
30214         if (flags & NDR_SET_VALUES) {
30215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30216         }
30217         if (flags & NDR_IN) {
30218                 ndr_print_struct(ndr, "in", "spoolss_6a");
30219                 ndr->depth++;
30220                 ndr->depth--;
30221         }
30222         if (flags & NDR_OUT) {
30223                 ndr_print_struct(ndr, "out", "spoolss_6a");
30224                 ndr->depth++;
30225                 ndr_print_WERROR(ndr, "result", r->out.result);
30226                 ndr->depth--;
30227         }
30228         ndr->depth--;
30229 }
30230
30231 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30232 {
30233         if (flags & NDR_IN) {
30234         }
30235         if (flags & NDR_OUT) {
30236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30237         }
30238         return NDR_ERR_SUCCESS;
30239 }
30240
30241 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30242 {
30243         if (flags & NDR_IN) {
30244         }
30245         if (flags & NDR_OUT) {
30246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30247         }
30248         return NDR_ERR_SUCCESS;
30249 }
30250
30251 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30252 {
30253         ndr_print_struct(ndr, name, "spoolss_6b");
30254         ndr->depth++;
30255         if (flags & NDR_SET_VALUES) {
30256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30257         }
30258         if (flags & NDR_IN) {
30259                 ndr_print_struct(ndr, "in", "spoolss_6b");
30260                 ndr->depth++;
30261                 ndr->depth--;
30262         }
30263         if (flags & NDR_OUT) {
30264                 ndr_print_struct(ndr, "out", "spoolss_6b");
30265                 ndr->depth++;
30266                 ndr_print_WERROR(ndr, "result", r->out.result);
30267                 ndr->depth--;
30268         }
30269         ndr->depth--;
30270 }
30271
30272 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30273 {
30274         if (flags & NDR_IN) {
30275         }
30276         if (flags & NDR_OUT) {
30277                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30278         }
30279         return NDR_ERR_SUCCESS;
30280 }
30281
30282 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30283 {
30284         if (flags & NDR_IN) {
30285         }
30286         if (flags & NDR_OUT) {
30287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30288         }
30289         return NDR_ERR_SUCCESS;
30290 }
30291
30292 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30293 {
30294         ndr_print_struct(ndr, name, "spoolss_6c");
30295         ndr->depth++;
30296         if (flags & NDR_SET_VALUES) {
30297                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30298         }
30299         if (flags & NDR_IN) {
30300                 ndr_print_struct(ndr, "in", "spoolss_6c");
30301                 ndr->depth++;
30302                 ndr->depth--;
30303         }
30304         if (flags & NDR_OUT) {
30305                 ndr_print_struct(ndr, "out", "spoolss_6c");
30306                 ndr->depth++;
30307                 ndr_print_WERROR(ndr, "result", r->out.result);
30308                 ndr->depth--;
30309         }
30310         ndr->depth--;
30311 }
30312
30313 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30314 {
30315         if (flags & NDR_IN) {
30316         }
30317         if (flags & NDR_OUT) {
30318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30319         }
30320         return NDR_ERR_SUCCESS;
30321 }
30322
30323 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30324 {
30325         if (flags & NDR_IN) {
30326         }
30327         if (flags & NDR_OUT) {
30328                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30329         }
30330         return NDR_ERR_SUCCESS;
30331 }
30332
30333 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30334 {
30335         ndr_print_struct(ndr, name, "spoolss_6d");
30336         ndr->depth++;
30337         if (flags & NDR_SET_VALUES) {
30338                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30339         }
30340         if (flags & NDR_IN) {
30341                 ndr_print_struct(ndr, "in", "spoolss_6d");
30342                 ndr->depth++;
30343                 ndr->depth--;
30344         }
30345         if (flags & NDR_OUT) {
30346                 ndr_print_struct(ndr, "out", "spoolss_6d");
30347                 ndr->depth++;
30348                 ndr_print_WERROR(ndr, "result", r->out.result);
30349                 ndr->depth--;
30350         }
30351         ndr->depth--;
30352 }
30353
30354 static const struct ndr_interface_call spoolss_calls[] = {
30355         {
30356                 "spoolss_EnumPrinters",
30357                 sizeof(struct spoolss_EnumPrinters),
30358                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30360                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30361                 false,
30362         },
30363         {
30364                 "spoolss_OpenPrinter",
30365                 sizeof(struct spoolss_OpenPrinter),
30366                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30368                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30369                 false,
30370         },
30371         {
30372                 "spoolss_SetJob",
30373                 sizeof(struct spoolss_SetJob),
30374                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30376                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30377                 false,
30378         },
30379         {
30380                 "spoolss_GetJob",
30381                 sizeof(struct spoolss_GetJob),
30382                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30384                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30385                 false,
30386         },
30387         {
30388                 "spoolss_EnumJobs",
30389                 sizeof(struct spoolss_EnumJobs),
30390                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30392                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30393                 false,
30394         },
30395         {
30396                 "spoolss_AddPrinter",
30397                 sizeof(struct spoolss_AddPrinter),
30398                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30400                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30401                 false,
30402         },
30403         {
30404                 "spoolss_DeletePrinter",
30405                 sizeof(struct spoolss_DeletePrinter),
30406                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30408                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30409                 false,
30410         },
30411         {
30412                 "spoolss_SetPrinter",
30413                 sizeof(struct spoolss_SetPrinter),
30414                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30416                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30417                 false,
30418         },
30419         {
30420                 "spoolss_GetPrinter",
30421                 sizeof(struct spoolss_GetPrinter),
30422                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30424                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30425                 false,
30426         },
30427         {
30428                 "spoolss_AddPrinterDriver",
30429                 sizeof(struct spoolss_AddPrinterDriver),
30430                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30432                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30433                 false,
30434         },
30435         {
30436                 "spoolss_EnumPrinterDrivers",
30437                 sizeof(struct spoolss_EnumPrinterDrivers),
30438                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30440                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30441                 false,
30442         },
30443         {
30444                 "spoolss_GetPrinterDriver",
30445                 sizeof(struct spoolss_GetPrinterDriver),
30446                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30448                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30449                 false,
30450         },
30451         {
30452                 "spoolss_GetPrinterDriverDirectory",
30453                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30454                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30456                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30457                 false,
30458         },
30459         {
30460                 "spoolss_DeletePrinterDriver",
30461                 sizeof(struct spoolss_DeletePrinterDriver),
30462                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30464                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30465                 false,
30466         },
30467         {
30468                 "spoolss_AddPrintProcessor",
30469                 sizeof(struct spoolss_AddPrintProcessor),
30470                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30472                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30473                 false,
30474         },
30475         {
30476                 "spoolss_EnumPrintProcessors",
30477                 sizeof(struct spoolss_EnumPrintProcessors),
30478                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30480                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30481                 false,
30482         },
30483         {
30484                 "spoolss_GetPrintProcessorDirectory",
30485                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30486                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30488                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30489                 false,
30490         },
30491         {
30492                 "spoolss_StartDocPrinter",
30493                 sizeof(struct spoolss_StartDocPrinter),
30494                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30496                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30497                 false,
30498         },
30499         {
30500                 "spoolss_StartPagePrinter",
30501                 sizeof(struct spoolss_StartPagePrinter),
30502                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30504                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30505                 false,
30506         },
30507         {
30508                 "spoolss_WritePrinter",
30509                 sizeof(struct spoolss_WritePrinter),
30510                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30512                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30513                 false,
30514         },
30515         {
30516                 "spoolss_EndPagePrinter",
30517                 sizeof(struct spoolss_EndPagePrinter),
30518                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30520                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30521                 false,
30522         },
30523         {
30524                 "spoolss_AbortPrinter",
30525                 sizeof(struct spoolss_AbortPrinter),
30526                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30528                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30529                 false,
30530         },
30531         {
30532                 "spoolss_ReadPrinter",
30533                 sizeof(struct spoolss_ReadPrinter),
30534                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30536                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30537                 false,
30538         },
30539         {
30540                 "spoolss_EndDocPrinter",
30541                 sizeof(struct spoolss_EndDocPrinter),
30542                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30544                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30545                 false,
30546         },
30547         {
30548                 "spoolss_AddJob",
30549                 sizeof(struct spoolss_AddJob),
30550                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30552                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30553                 false,
30554         },
30555         {
30556                 "spoolss_ScheduleJob",
30557                 sizeof(struct spoolss_ScheduleJob),
30558                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30560                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30561                 false,
30562         },
30563         {
30564                 "spoolss_GetPrinterData",
30565                 sizeof(struct spoolss_GetPrinterData),
30566                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30568                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30569                 false,
30570         },
30571         {
30572                 "spoolss_SetPrinterData",
30573                 sizeof(struct spoolss_SetPrinterData),
30574                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30576                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30577                 false,
30578         },
30579         {
30580                 "spoolss_WaitForPrinterChange",
30581                 sizeof(struct spoolss_WaitForPrinterChange),
30582                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30584                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30585                 false,
30586         },
30587         {
30588                 "spoolss_ClosePrinter",
30589                 sizeof(struct spoolss_ClosePrinter),
30590                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30592                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30593                 false,
30594         },
30595         {
30596                 "spoolss_AddForm",
30597                 sizeof(struct spoolss_AddForm),
30598                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30600                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30601                 false,
30602         },
30603         {
30604                 "spoolss_DeleteForm",
30605                 sizeof(struct spoolss_DeleteForm),
30606                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30608                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30609                 false,
30610         },
30611         {
30612                 "spoolss_GetForm",
30613                 sizeof(struct spoolss_GetForm),
30614                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30616                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30617                 false,
30618         },
30619         {
30620                 "spoolss_SetForm",
30621                 sizeof(struct spoolss_SetForm),
30622                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30624                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30625                 false,
30626         },
30627         {
30628                 "spoolss_EnumForms",
30629                 sizeof(struct spoolss_EnumForms),
30630                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30632                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30633                 false,
30634         },
30635         {
30636                 "spoolss_EnumPorts",
30637                 sizeof(struct spoolss_EnumPorts),
30638                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30640                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30641                 false,
30642         },
30643         {
30644                 "spoolss_EnumMonitors",
30645                 sizeof(struct spoolss_EnumMonitors),
30646                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30648                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30649                 false,
30650         },
30651         {
30652                 "spoolss_AddPort",
30653                 sizeof(struct spoolss_AddPort),
30654                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30656                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30657                 false,
30658         },
30659         {
30660                 "spoolss_ConfigurePort",
30661                 sizeof(struct spoolss_ConfigurePort),
30662                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30664                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30665                 false,
30666         },
30667         {
30668                 "spoolss_DeletePort",
30669                 sizeof(struct spoolss_DeletePort),
30670                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30672                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30673                 false,
30674         },
30675         {
30676                 "spoolss_CreatePrinterIC",
30677                 sizeof(struct spoolss_CreatePrinterIC),
30678                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30680                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30681                 false,
30682         },
30683         {
30684                 "spoolss_PlayGDIScriptOnPrinterIC",
30685                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30686                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30688                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30689                 false,
30690         },
30691         {
30692                 "spoolss_DeletePrinterIC",
30693                 sizeof(struct spoolss_DeletePrinterIC),
30694                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30696                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30697                 false,
30698         },
30699         {
30700                 "spoolss_AddPrinterConnection",
30701                 sizeof(struct spoolss_AddPrinterConnection),
30702                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30704                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30705                 false,
30706         },
30707         {
30708                 "spoolss_DeletePrinterConnection",
30709                 sizeof(struct spoolss_DeletePrinterConnection),
30710                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30712                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30713                 false,
30714         },
30715         {
30716                 "spoolss_PrinterMessageBox",
30717                 sizeof(struct spoolss_PrinterMessageBox),
30718                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30720                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30721                 false,
30722         },
30723         {
30724                 "spoolss_AddMonitor",
30725                 sizeof(struct spoolss_AddMonitor),
30726                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30728                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30729                 false,
30730         },
30731         {
30732                 "spoolss_DeleteMonitor",
30733                 sizeof(struct spoolss_DeleteMonitor),
30734                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30736                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30737                 false,
30738         },
30739         {
30740                 "spoolss_DeletePrintProcessor",
30741                 sizeof(struct spoolss_DeletePrintProcessor),
30742                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30744                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30745                 false,
30746         },
30747         {
30748                 "spoolss_AddPrintProvidor",
30749                 sizeof(struct spoolss_AddPrintProvidor),
30750                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30752                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30753                 false,
30754         },
30755         {
30756                 "spoolss_DeletePrintProvidor",
30757                 sizeof(struct spoolss_DeletePrintProvidor),
30758                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30760                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30761                 false,
30762         },
30763         {
30764                 "spoolss_EnumPrintProcDataTypes",
30765                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30766                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30768                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30769                 false,
30770         },
30771         {
30772                 "spoolss_ResetPrinter",
30773                 sizeof(struct spoolss_ResetPrinter),
30774                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30776                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30777                 false,
30778         },
30779         {
30780                 "spoolss_GetPrinterDriver2",
30781                 sizeof(struct spoolss_GetPrinterDriver2),
30782                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30784                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30785                 false,
30786         },
30787         {
30788                 "spoolss_FindFirstPrinterChangeNotification",
30789                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30790                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30792                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30793                 false,
30794         },
30795         {
30796                 "spoolss_FindNextPrinterChangeNotification",
30797                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30798                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30800                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30801                 false,
30802         },
30803         {
30804                 "spoolss_FindClosePrinterNotify",
30805                 sizeof(struct spoolss_FindClosePrinterNotify),
30806                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30808                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30809                 false,
30810         },
30811         {
30812                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30813                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30814                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30816                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30817                 false,
30818         },
30819         {
30820                 "spoolss_ReplyOpenPrinter",
30821                 sizeof(struct spoolss_ReplyOpenPrinter),
30822                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30824                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30825                 false,
30826         },
30827         {
30828                 "spoolss_RouterReplyPrinter",
30829                 sizeof(struct spoolss_RouterReplyPrinter),
30830                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30832                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30833                 false,
30834         },
30835         {
30836                 "spoolss_ReplyClosePrinter",
30837                 sizeof(struct spoolss_ReplyClosePrinter),
30838                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30840                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30841                 false,
30842         },
30843         {
30844                 "spoolss_AddPortEx",
30845                 sizeof(struct spoolss_AddPortEx),
30846                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30848                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30849                 false,
30850         },
30851         {
30852                 "spoolss_RouterFindFirstPrinterChangeNotification",
30853                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30854                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30856                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30857                 false,
30858         },
30859         {
30860                 "spoolss_SpoolerInit",
30861                 sizeof(struct spoolss_SpoolerInit),
30862                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30864                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30865                 false,
30866         },
30867         {
30868                 "spoolss_ResetPrinterEx",
30869                 sizeof(struct spoolss_ResetPrinterEx),
30870                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30872                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30873                 false,
30874         },
30875         {
30876                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30877                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30878                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30880                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30881                 false,
30882         },
30883         {
30884                 "spoolss_RouterReplyPrinterEx",
30885                 sizeof(struct spoolss_RouterReplyPrinterEx),
30886                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30888                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30889                 false,
30890         },
30891         {
30892                 "spoolss_RouterRefreshPrinterChangeNotify",
30893                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30894                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30896                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30897                 false,
30898         },
30899         {
30900                 "spoolss_44",
30901                 sizeof(struct spoolss_44),
30902                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30904                 (ndr_print_function_t) ndr_print_spoolss_44,
30905                 false,
30906         },
30907         {
30908                 "spoolss_OpenPrinterEx",
30909                 sizeof(struct spoolss_OpenPrinterEx),
30910                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30912                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30913                 false,
30914         },
30915         {
30916                 "spoolss_AddPrinterEx",
30917                 sizeof(struct spoolss_AddPrinterEx),
30918                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30920                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30921                 false,
30922         },
30923         {
30924                 "spoolss_47",
30925                 sizeof(struct spoolss_47),
30926                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30928                 (ndr_print_function_t) ndr_print_spoolss_47,
30929                 false,
30930         },
30931         {
30932                 "spoolss_EnumPrinterData",
30933                 sizeof(struct spoolss_EnumPrinterData),
30934                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30936                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30937                 false,
30938         },
30939         {
30940                 "spoolss_DeletePrinterData",
30941                 sizeof(struct spoolss_DeletePrinterData),
30942                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30944                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30945                 false,
30946         },
30947         {
30948                 "spoolss_4a",
30949                 sizeof(struct spoolss_4a),
30950                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30952                 (ndr_print_function_t) ndr_print_spoolss_4a,
30953                 false,
30954         },
30955         {
30956                 "spoolss_4b",
30957                 sizeof(struct spoolss_4b),
30958                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30960                 (ndr_print_function_t) ndr_print_spoolss_4b,
30961                 false,
30962         },
30963         {
30964                 "spoolss_4c",
30965                 sizeof(struct spoolss_4c),
30966                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30968                 (ndr_print_function_t) ndr_print_spoolss_4c,
30969                 false,
30970         },
30971         {
30972                 "spoolss_SetPrinterDataEx",
30973                 sizeof(struct spoolss_SetPrinterDataEx),
30974                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30975                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30976                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30977                 false,
30978         },
30979         {
30980                 "spoolss_GetPrinterDataEx",
30981                 sizeof(struct spoolss_GetPrinterDataEx),
30982                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30984                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30985                 false,
30986         },
30987         {
30988                 "spoolss_EnumPrinterDataEx",
30989                 sizeof(struct spoolss_EnumPrinterDataEx),
30990                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30992                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30993                 false,
30994         },
30995         {
30996                 "spoolss_EnumPrinterKey",
30997                 sizeof(struct spoolss_EnumPrinterKey),
30998                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
30999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31000                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31001                 false,
31002         },
31003         {
31004                 "spoolss_DeletePrinterDataEx",
31005                 sizeof(struct spoolss_DeletePrinterDataEx),
31006                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31008                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31009                 false,
31010         },
31011         {
31012                 "spoolss_DeletePrinterKey",
31013                 sizeof(struct spoolss_DeletePrinterKey),
31014                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31015                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31016                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31017                 false,
31018         },
31019         {
31020                 "spoolss_53",
31021                 sizeof(struct spoolss_53),
31022                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31023                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31024                 (ndr_print_function_t) ndr_print_spoolss_53,
31025                 false,
31026         },
31027         {
31028                 "spoolss_DeletePrinterDriverEx",
31029                 sizeof(struct spoolss_DeletePrinterDriverEx),
31030                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31031                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31032                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31033                 false,
31034         },
31035         {
31036                 "spoolss_55",
31037                 sizeof(struct spoolss_55),
31038                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31039                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31040                 (ndr_print_function_t) ndr_print_spoolss_55,
31041                 false,
31042         },
31043         {
31044                 "spoolss_56",
31045                 sizeof(struct spoolss_56),
31046                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31047                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31048                 (ndr_print_function_t) ndr_print_spoolss_56,
31049                 false,
31050         },
31051         {
31052                 "spoolss_57",
31053                 sizeof(struct spoolss_57),
31054                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31055                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31056                 (ndr_print_function_t) ndr_print_spoolss_57,
31057                 false,
31058         },
31059         {
31060                 "spoolss_XcvData",
31061                 sizeof(struct spoolss_XcvData),
31062                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31063                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31064                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31065                 false,
31066         },
31067         {
31068                 "spoolss_AddPrinterDriverEx",
31069                 sizeof(struct spoolss_AddPrinterDriverEx),
31070                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31071                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31072                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31073                 false,
31074         },
31075         {
31076                 "spoolss_5a",
31077                 sizeof(struct spoolss_5a),
31078                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31079                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31080                 (ndr_print_function_t) ndr_print_spoolss_5a,
31081                 false,
31082         },
31083         {
31084                 "spoolss_5b",
31085                 sizeof(struct spoolss_5b),
31086                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31087                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31088                 (ndr_print_function_t) ndr_print_spoolss_5b,
31089                 false,
31090         },
31091         {
31092                 "spoolss_5c",
31093                 sizeof(struct spoolss_5c),
31094                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31095                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31096                 (ndr_print_function_t) ndr_print_spoolss_5c,
31097                 false,
31098         },
31099         {
31100                 "spoolss_5d",
31101                 sizeof(struct spoolss_5d),
31102                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31103                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31104                 (ndr_print_function_t) ndr_print_spoolss_5d,
31105                 false,
31106         },
31107         {
31108                 "spoolss_5e",
31109                 sizeof(struct spoolss_5e),
31110                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31111                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31112                 (ndr_print_function_t) ndr_print_spoolss_5e,
31113                 false,
31114         },
31115         {
31116                 "spoolss_5f",
31117                 sizeof(struct spoolss_5f),
31118                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31119                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31120                 (ndr_print_function_t) ndr_print_spoolss_5f,
31121                 false,
31122         },
31123         {
31124                 "spoolss_60",
31125                 sizeof(struct spoolss_60),
31126                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31127                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31128                 (ndr_print_function_t) ndr_print_spoolss_60,
31129                 false,
31130         },
31131         {
31132                 "spoolss_61",
31133                 sizeof(struct spoolss_61),
31134                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31135                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31136                 (ndr_print_function_t) ndr_print_spoolss_61,
31137                 false,
31138         },
31139         {
31140                 "spoolss_62",
31141                 sizeof(struct spoolss_62),
31142                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31143                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31144                 (ndr_print_function_t) ndr_print_spoolss_62,
31145                 false,
31146         },
31147         {
31148                 "spoolss_63",
31149                 sizeof(struct spoolss_63),
31150                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31152                 (ndr_print_function_t) ndr_print_spoolss_63,
31153                 false,
31154         },
31155         {
31156                 "spoolss_64",
31157                 sizeof(struct spoolss_64),
31158                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31160                 (ndr_print_function_t) ndr_print_spoolss_64,
31161                 false,
31162         },
31163         {
31164                 "spoolss_65",
31165                 sizeof(struct spoolss_65),
31166                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31168                 (ndr_print_function_t) ndr_print_spoolss_65,
31169                 false,
31170         },
31171         {
31172                 "spoolss_GetCorePrinterDrivers",
31173                 sizeof(struct spoolss_GetCorePrinterDrivers),
31174                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31176                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31177                 false,
31178         },
31179         {
31180                 "spoolss_67",
31181                 sizeof(struct spoolss_67),
31182                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31184                 (ndr_print_function_t) ndr_print_spoolss_67,
31185                 false,
31186         },
31187         {
31188                 "spoolss_GetPrinterDriverPackagePath",
31189                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31190                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31192                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31193                 false,
31194         },
31195         {
31196                 "spoolss_69",
31197                 sizeof(struct spoolss_69),
31198                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31200                 (ndr_print_function_t) ndr_print_spoolss_69,
31201                 false,
31202         },
31203         {
31204                 "spoolss_6a",
31205                 sizeof(struct spoolss_6a),
31206                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31208                 (ndr_print_function_t) ndr_print_spoolss_6a,
31209                 false,
31210         },
31211         {
31212                 "spoolss_6b",
31213                 sizeof(struct spoolss_6b),
31214                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31216                 (ndr_print_function_t) ndr_print_spoolss_6b,
31217                 false,
31218         },
31219         {
31220                 "spoolss_6c",
31221                 sizeof(struct spoolss_6c),
31222                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31224                 (ndr_print_function_t) ndr_print_spoolss_6c,
31225                 false,
31226         },
31227         {
31228                 "spoolss_6d",
31229                 sizeof(struct spoolss_6d),
31230                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31232                 (ndr_print_function_t) ndr_print_spoolss_6d,
31233                 false,
31234         },
31235         { NULL, 0, NULL, NULL, NULL, false }
31236 };
31237
31238 static const char * const spoolss_endpoint_strings[] = {
31239         "ncacn_np:[\\pipe\\spoolss]",
31240 };
31241
31242 static const struct ndr_interface_string_array spoolss_endpoints = {
31243         .count  = 1,
31244         .names  = spoolss_endpoint_strings
31245 };
31246
31247 static const char * const spoolss_authservice_strings[] = {
31248         "host",
31249 };
31250
31251 static const struct ndr_interface_string_array spoolss_authservices = {
31252         .count  = 1,
31253         .names  = spoolss_authservice_strings
31254 };
31255
31256
31257 const struct ndr_interface_table ndr_table_spoolss = {
31258         .name           = "spoolss",
31259         .syntax_id      = {
31260                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31261                 NDR_SPOOLSS_VERSION
31262         },
31263         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31264         .num_calls      = 110,
31265         .calls          = spoolss_calls,
31266         .endpoints      = &spoolss_endpoints,
31267         .authservices   = &spoolss_authservices
31268 };
31269