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_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
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_uint32(ndr, NDR_SCALARS, r->secdesc_ptr));
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->sepfile) {
6844                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6847                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6848                 }
6849                 if (r->printprocessor) {
6850                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6851                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6853                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6854                 }
6855                 if (r->datatype) {
6856                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6857                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6858                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6860                 }
6861                 if (r->parameters) {
6862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6864                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6866                 }
6867         }
6868         return NDR_ERR_SUCCESS;
6869 }
6870
6871 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6872 {
6873         uint32_t _ptr_servername;
6874         TALLOC_CTX *_mem_save_servername_0;
6875         uint32_t _ptr_printername;
6876         TALLOC_CTX *_mem_save_printername_0;
6877         uint32_t _ptr_sharename;
6878         TALLOC_CTX *_mem_save_sharename_0;
6879         uint32_t _ptr_portname;
6880         TALLOC_CTX *_mem_save_portname_0;
6881         uint32_t _ptr_drivername;
6882         TALLOC_CTX *_mem_save_drivername_0;
6883         uint32_t _ptr_comment;
6884         TALLOC_CTX *_mem_save_comment_0;
6885         uint32_t _ptr_location;
6886         TALLOC_CTX *_mem_save_location_0;
6887         uint32_t _ptr_sepfile;
6888         TALLOC_CTX *_mem_save_sepfile_0;
6889         uint32_t _ptr_printprocessor;
6890         TALLOC_CTX *_mem_save_printprocessor_0;
6891         uint32_t _ptr_datatype;
6892         TALLOC_CTX *_mem_save_datatype_0;
6893         uint32_t _ptr_parameters;
6894         TALLOC_CTX *_mem_save_parameters_0;
6895         if (ndr_flags & NDR_SCALARS) {
6896                 NDR_CHECK(ndr_pull_align(ndr, 5));
6897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6898                 if (_ptr_servername) {
6899                         NDR_PULL_ALLOC(ndr, r->servername);
6900                 } else {
6901                         r->servername = NULL;
6902                 }
6903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6904                 if (_ptr_printername) {
6905                         NDR_PULL_ALLOC(ndr, r->printername);
6906                 } else {
6907                         r->printername = NULL;
6908                 }
6909                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6910                 if (_ptr_sharename) {
6911                         NDR_PULL_ALLOC(ndr, r->sharename);
6912                 } else {
6913                         r->sharename = NULL;
6914                 }
6915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6916                 if (_ptr_portname) {
6917                         NDR_PULL_ALLOC(ndr, r->portname);
6918                 } else {
6919                         r->portname = NULL;
6920                 }
6921                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6922                 if (_ptr_drivername) {
6923                         NDR_PULL_ALLOC(ndr, r->drivername);
6924                 } else {
6925                         r->drivername = NULL;
6926                 }
6927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6928                 if (_ptr_comment) {
6929                         NDR_PULL_ALLOC(ndr, r->comment);
6930                 } else {
6931                         r->comment = NULL;
6932                 }
6933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6934                 if (_ptr_location) {
6935                         NDR_PULL_ALLOC(ndr, r->location);
6936                 } else {
6937                         r->location = NULL;
6938                 }
6939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
6940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6941                 if (_ptr_sepfile) {
6942                         NDR_PULL_ALLOC(ndr, r->sepfile);
6943                 } else {
6944                         r->sepfile = NULL;
6945                 }
6946                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6947                 if (_ptr_printprocessor) {
6948                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6949                 } else {
6950                         r->printprocessor = NULL;
6951                 }
6952                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6953                 if (_ptr_datatype) {
6954                         NDR_PULL_ALLOC(ndr, r->datatype);
6955                 } else {
6956                         r->datatype = NULL;
6957                 }
6958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6959                 if (_ptr_parameters) {
6960                         NDR_PULL_ALLOC(ndr, r->parameters);
6961                 } else {
6962                         r->parameters = NULL;
6963                 }
6964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->secdesc_ptr));
6965                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6967                 if (r->priority > 99) {
6968                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6969                 }
6970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6973                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6976                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6977         }
6978         if (ndr_flags & NDR_BUFFERS) {
6979                 if (r->servername) {
6980                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6981                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6984                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6985                                 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));
6986                         }
6987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6990                 }
6991                 if (r->printername) {
6992                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6993                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6996                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6997                                 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));
6998                         }
6999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7002                 }
7003                 if (r->sharename) {
7004                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
7005                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
7006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
7007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
7008                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
7009                                 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));
7010                         }
7011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
7012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
7013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
7014                 }
7015                 if (r->portname) {
7016                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7017                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7020                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7021                                 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));
7022                         }
7023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7024                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7026                 }
7027                 if (r->drivername) {
7028                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7029                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
7030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
7031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
7032                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
7033                                 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));
7034                         }
7035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
7036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
7037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
7038                 }
7039                 if (r->comment) {
7040                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7041                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
7042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
7043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
7044                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
7045                                 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));
7046                         }
7047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
7048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
7049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
7050                 }
7051                 if (r->location) {
7052                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
7053                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
7054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
7055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
7056                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
7057                                 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));
7058                         }
7059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
7060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
7061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
7062                 }
7063                 if (r->sepfile) {
7064                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
7065                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
7066                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
7067                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
7068                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
7069                                 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));
7070                         }
7071                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
7072                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
7073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
7074                 }
7075                 if (r->printprocessor) {
7076                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7077                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
7078                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
7079                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
7080                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
7081                                 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));
7082                         }
7083                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
7084                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
7085                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
7086                 }
7087                 if (r->datatype) {
7088                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7089                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
7090                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
7091                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
7092                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
7093                                 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));
7094                         }
7095                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
7096                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
7097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
7098                 }
7099                 if (r->parameters) {
7100                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
7101                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
7102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
7103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
7104                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
7105                                 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));
7106                         }
7107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
7108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
7109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
7110                 }
7111         }
7112         return NDR_ERR_SUCCESS;
7113 }
7114
7115 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
7116 {
7117         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
7118         ndr->depth++;
7119         ndr_print_ptr(ndr, "servername", r->servername);
7120         ndr->depth++;
7121         if (r->servername) {
7122                 ndr_print_string(ndr, "servername", r->servername);
7123         }
7124         ndr->depth--;
7125         ndr_print_ptr(ndr, "printername", r->printername);
7126         ndr->depth++;
7127         if (r->printername) {
7128                 ndr_print_string(ndr, "printername", r->printername);
7129         }
7130         ndr->depth--;
7131         ndr_print_ptr(ndr, "sharename", r->sharename);
7132         ndr->depth++;
7133         if (r->sharename) {
7134                 ndr_print_string(ndr, "sharename", r->sharename);
7135         }
7136         ndr->depth--;
7137         ndr_print_ptr(ndr, "portname", r->portname);
7138         ndr->depth++;
7139         if (r->portname) {
7140                 ndr_print_string(ndr, "portname", r->portname);
7141         }
7142         ndr->depth--;
7143         ndr_print_ptr(ndr, "drivername", r->drivername);
7144         ndr->depth++;
7145         if (r->drivername) {
7146                 ndr_print_string(ndr, "drivername", r->drivername);
7147         }
7148         ndr->depth--;
7149         ndr_print_ptr(ndr, "comment", r->comment);
7150         ndr->depth++;
7151         if (r->comment) {
7152                 ndr_print_string(ndr, "comment", r->comment);
7153         }
7154         ndr->depth--;
7155         ndr_print_ptr(ndr, "location", r->location);
7156         ndr->depth++;
7157         if (r->location) {
7158                 ndr_print_string(ndr, "location", r->location);
7159         }
7160         ndr->depth--;
7161         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7162         ndr_print_ptr(ndr, "sepfile", r->sepfile);
7163         ndr->depth++;
7164         if (r->sepfile) {
7165                 ndr_print_string(ndr, "sepfile", r->sepfile);
7166         }
7167         ndr->depth--;
7168         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
7169         ndr->depth++;
7170         if (r->printprocessor) {
7171                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
7172         }
7173         ndr->depth--;
7174         ndr_print_ptr(ndr, "datatype", r->datatype);
7175         ndr->depth++;
7176         if (r->datatype) {
7177                 ndr_print_string(ndr, "datatype", r->datatype);
7178         }
7179         ndr->depth--;
7180         ndr_print_ptr(ndr, "parameters", r->parameters);
7181         ndr->depth++;
7182         if (r->parameters) {
7183                 ndr_print_string(ndr, "parameters", r->parameters);
7184         }
7185         ndr->depth--;
7186         ndr_print_uint32(ndr, "secdesc_ptr", r->secdesc_ptr);
7187         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7188         ndr_print_uint32(ndr, "priority", r->priority);
7189         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
7190         ndr_print_uint32(ndr, "starttime", r->starttime);
7191         ndr_print_uint32(ndr, "untiltime", r->untiltime);
7192         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7193         ndr_print_uint32(ndr, "cjobs", r->cjobs);
7194         ndr_print_uint32(ndr, "averageppm", r->averageppm);
7195         ndr->depth--;
7196 }
7197
7198 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
7199 {
7200         if (ndr_flags & NDR_SCALARS) {
7201                 NDR_CHECK(ndr_push_align(ndr, 4));
7202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
7203                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7204         }
7205         if (ndr_flags & NDR_BUFFERS) {
7206         }
7207         return NDR_ERR_SUCCESS;
7208 }
7209
7210 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
7211 {
7212         if (ndr_flags & NDR_SCALARS) {
7213                 NDR_CHECK(ndr_pull_align(ndr, 4));
7214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
7215                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7216         }
7217         if (ndr_flags & NDR_BUFFERS) {
7218         }
7219         return NDR_ERR_SUCCESS;
7220 }
7221
7222 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
7223 {
7224         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
7225         ndr->depth++;
7226         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
7227         ndr->depth--;
7228 }
7229
7230 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
7231 {
7232         if (ndr_flags & NDR_SCALARS) {
7233                 NDR_CHECK(ndr_push_align(ndr, 5));
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
7236                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7237                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7238         }
7239         if (ndr_flags & NDR_BUFFERS) {
7240                 if (r->printername) {
7241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7242                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7245                 }
7246                 if (r->servername) {
7247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
7250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7251                 }
7252         }
7253         return NDR_ERR_SUCCESS;
7254 }
7255
7256 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
7257 {
7258         uint32_t _ptr_printername;
7259         TALLOC_CTX *_mem_save_printername_0;
7260         uint32_t _ptr_servername;
7261         TALLOC_CTX *_mem_save_servername_0;
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_pull_align(ndr, 5));
7264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7265                 if (_ptr_printername) {
7266                         NDR_PULL_ALLOC(ndr, r->printername);
7267                 } else {
7268                         r->printername = NULL;
7269                 }
7270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
7271                 if (_ptr_servername) {
7272                         NDR_PULL_ALLOC(ndr, r->servername);
7273                 } else {
7274                         r->servername = NULL;
7275                 }
7276                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7277                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7278         }
7279         if (ndr_flags & NDR_BUFFERS) {
7280                 if (r->printername) {
7281                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7282                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7283                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7284                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7285                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7286                                 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));
7287                         }
7288                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7289                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7291                 }
7292                 if (r->servername) {
7293                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7294                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
7295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
7296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
7297                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
7298                                 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));
7299                         }
7300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
7301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
7302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
7303                 }
7304         }
7305         return NDR_ERR_SUCCESS;
7306 }
7307
7308 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
7309 {
7310         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
7311         ndr->depth++;
7312         ndr_print_ptr(ndr, "printername", r->printername);
7313         ndr->depth++;
7314         if (r->printername) {
7315                 ndr_print_string(ndr, "printername", r->printername);
7316         }
7317         ndr->depth--;
7318         ndr_print_ptr(ndr, "servername", r->servername);
7319         ndr->depth++;
7320         if (r->servername) {
7321                 ndr_print_string(ndr, "servername", r->servername);
7322         }
7323         ndr->depth--;
7324         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7325         ndr->depth--;
7326 }
7327
7328 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
7329 {
7330         if (ndr_flags & NDR_SCALARS) {
7331                 NDR_CHECK(ndr_push_align(ndr, 5));
7332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
7333                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
7334                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
7335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
7336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
7337                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7338         }
7339         if (ndr_flags & NDR_BUFFERS) {
7340                 if (r->printername) {
7341                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7343                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
7344                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7345                 }
7346                 if (r->portname) {
7347                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7348                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
7350                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7351                 }
7352         }
7353         return NDR_ERR_SUCCESS;
7354 }
7355
7356 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
7357 {
7358         uint32_t _ptr_printername;
7359         TALLOC_CTX *_mem_save_printername_0;
7360         uint32_t _ptr_portname;
7361         TALLOC_CTX *_mem_save_portname_0;
7362         if (ndr_flags & NDR_SCALARS) {
7363                 NDR_CHECK(ndr_pull_align(ndr, 5));
7364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
7365                 if (_ptr_printername) {
7366                         NDR_PULL_ALLOC(ndr, r->printername);
7367                 } else {
7368                         r->printername = NULL;
7369                 }
7370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
7371                 if (_ptr_portname) {
7372                         NDR_PULL_ALLOC(ndr, r->portname);
7373                 } else {
7374                         r->portname = NULL;
7375                 }
7376                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
7377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
7378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
7379                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7380         }
7381         if (ndr_flags & NDR_BUFFERS) {
7382                 if (r->printername) {
7383                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
7384                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
7385                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
7386                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
7387                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
7388                                 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));
7389                         }
7390                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
7391                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
7392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
7393                 }
7394                 if (r->portname) {
7395                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
7396                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
7397                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
7398                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
7399                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
7400                                 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));
7401                         }
7402                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
7403                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
7404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
7405                 }
7406         }
7407         return NDR_ERR_SUCCESS;
7408 }
7409
7410 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
7411 {
7412         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
7413         ndr->depth++;
7414         ndr_print_ptr(ndr, "printername", r->printername);
7415         ndr->depth++;
7416         if (r->printername) {
7417                 ndr_print_string(ndr, "printername", r->printername);
7418         }
7419         ndr->depth--;
7420         ndr_print_ptr(ndr, "portname", r->portname);
7421         ndr->depth++;
7422         if (r->portname) {
7423                 ndr_print_string(ndr, "portname", r->portname);
7424         }
7425         ndr->depth--;
7426         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
7427         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
7428         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
7429         ndr->depth--;
7430 }
7431
7432 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
7433 {
7434         if (ndr_flags & NDR_SCALARS) {
7435                 NDR_CHECK(ndr_push_align(ndr, 4));
7436                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
7437                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7438         }
7439         if (ndr_flags & NDR_BUFFERS) {
7440         }
7441         return NDR_ERR_SUCCESS;
7442 }
7443
7444 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
7445 {
7446         if (ndr_flags & NDR_SCALARS) {
7447                 NDR_CHECK(ndr_pull_align(ndr, 4));
7448                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
7449                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7450         }
7451         if (ndr_flags & NDR_BUFFERS) {
7452         }
7453         return NDR_ERR_SUCCESS;
7454 }
7455
7456 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
7457 {
7458         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
7459         ndr->depth++;
7460         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
7461         ndr->depth--;
7462 }
7463
7464 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
7465 {
7466         if (ndr_flags & NDR_SCALARS) {
7467                 NDR_CHECK(ndr_push_align(ndr, 5));
7468                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
7469                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
7470                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7471         }
7472         if (ndr_flags & NDR_BUFFERS) {
7473                 if (r->guid) {
7474                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
7477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7478                 }
7479         }
7480         return NDR_ERR_SUCCESS;
7481 }
7482
7483 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
7484 {
7485         uint32_t _ptr_guid;
7486         TALLOC_CTX *_mem_save_guid_0;
7487         if (ndr_flags & NDR_SCALARS) {
7488                 NDR_CHECK(ndr_pull_align(ndr, 5));
7489                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
7490                 if (_ptr_guid) {
7491                         NDR_PULL_ALLOC(ndr, r->guid);
7492                 } else {
7493                         r->guid = NULL;
7494                 }
7495                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
7496                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7497         }
7498         if (ndr_flags & NDR_BUFFERS) {
7499                 if (r->guid) {
7500                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
7501                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
7502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
7503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
7504                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
7505                                 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));
7506                         }
7507                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
7508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
7509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
7510                 }
7511         }
7512         return NDR_ERR_SUCCESS;
7513 }
7514
7515 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
7516 {
7517         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
7518         ndr->depth++;
7519         ndr_print_ptr(ndr, "guid", r->guid);
7520         ndr->depth++;
7521         if (r->guid) {
7522                 ndr_print_string(ndr, "guid", r->guid);
7523         }
7524         ndr->depth--;
7525         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
7526         ndr->depth--;
7527 }
7528
7529 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo8 *r)
7530 {
7531         if (ndr_flags & NDR_SCALARS) {
7532                 NDR_CHECK(ndr_push_align(ndr, 4));
7533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7534                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7535         }
7536         if (ndr_flags & NDR_BUFFERS) {
7537         }
7538         return NDR_ERR_SUCCESS;
7539 }
7540
7541 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo8 *r)
7542 {
7543         if (ndr_flags & NDR_SCALARS) {
7544                 NDR_CHECK(ndr_pull_align(ndr, 4));
7545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7546                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7547         }
7548         if (ndr_flags & NDR_BUFFERS) {
7549         }
7550         return NDR_ERR_SUCCESS;
7551 }
7552
7553 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo8 *r)
7554 {
7555         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo8");
7556         ndr->depth++;
7557         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7558         ndr->depth--;
7559 }
7560
7561 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo9(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo9 *r)
7562 {
7563         if (ndr_flags & NDR_SCALARS) {
7564                 NDR_CHECK(ndr_push_align(ndr, 4));
7565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->devmode_ptr));
7566                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
7567         }
7568         if (ndr_flags & NDR_BUFFERS) {
7569         }
7570         return NDR_ERR_SUCCESS;
7571 }
7572
7573 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo9(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo9 *r)
7574 {
7575         if (ndr_flags & NDR_SCALARS) {
7576                 NDR_CHECK(ndr_pull_align(ndr, 4));
7577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->devmode_ptr));
7578                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
7579         }
7580         if (ndr_flags & NDR_BUFFERS) {
7581         }
7582         return NDR_ERR_SUCCESS;
7583 }
7584
7585 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo9(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo9 *r)
7586 {
7587         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo9");
7588         ndr->depth++;
7589         ndr_print_uint32(ndr, "devmode_ptr", r->devmode_ptr);
7590         ndr->depth--;
7591 }
7592
7593 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
7594 {
7595         if (ndr_flags & NDR_SCALARS) {
7596                 int level = ndr_push_get_switch_value(ndr, r);
7597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7598                 NDR_CHECK(ndr_push_union_align(ndr, 5));
7599                 switch (level) {
7600                         case 0: {
7601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
7602                         break; }
7603
7604                         case 1: {
7605                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7606                         break; }
7607
7608                         case 2: {
7609                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
7610                         break; }
7611
7612                         case 3: {
7613                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
7614                         break; }
7615
7616                         case 4: {
7617                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
7618                         break; }
7619
7620                         case 5: {
7621                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
7622                         break; }
7623
7624                         case 6: {
7625                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
7626                         break; }
7627
7628                         case 7: {
7629                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
7630                         break; }
7631
7632                         case 8: {
7633                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
7634                         break; }
7635
7636                         case 9: {
7637                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
7638                         break; }
7639
7640                         default: {
7641                         break; }
7642
7643                 }
7644         }
7645         if (ndr_flags & NDR_BUFFERS) {
7646                 int level = ndr_push_get_switch_value(ndr, r);
7647                 switch (level) {
7648                         case 0:
7649                                 if (r->info0) {
7650                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7651                                 }
7652                         break;
7653
7654                         case 1:
7655                                 if (r->info1) {
7656                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7657                                 }
7658                         break;
7659
7660                         case 2:
7661                                 if (r->info2) {
7662                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7663                                 }
7664                         break;
7665
7666                         case 3:
7667                                 if (r->info3) {
7668                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7669                                 }
7670                         break;
7671
7672                         case 4:
7673                                 if (r->info4) {
7674                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7675                                 }
7676                         break;
7677
7678                         case 5:
7679                                 if (r->info5) {
7680                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7681                                 }
7682                         break;
7683
7684                         case 6:
7685                                 if (r->info6) {
7686                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7687                                 }
7688                         break;
7689
7690                         case 7:
7691                                 if (r->info7) {
7692                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7693                                 }
7694                         break;
7695
7696                         case 8:
7697                                 if (r->info8) {
7698                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7699                                 }
7700                         break;
7701
7702                         case 9:
7703                                 if (r->info9) {
7704                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7705                                 }
7706                         break;
7707
7708                         default:
7709                         break;
7710
7711                 }
7712         }
7713         return NDR_ERR_SUCCESS;
7714 }
7715
7716 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7717 {
7718         int level;
7719         uint32_t _level;
7720         TALLOC_CTX *_mem_save_info0_0;
7721         TALLOC_CTX *_mem_save_info1_0;
7722         TALLOC_CTX *_mem_save_info2_0;
7723         TALLOC_CTX *_mem_save_info3_0;
7724         TALLOC_CTX *_mem_save_info4_0;
7725         TALLOC_CTX *_mem_save_info5_0;
7726         TALLOC_CTX *_mem_save_info6_0;
7727         TALLOC_CTX *_mem_save_info7_0;
7728         TALLOC_CTX *_mem_save_info8_0;
7729         TALLOC_CTX *_mem_save_info9_0;
7730         level = ndr_pull_get_switch_value(ndr, r);
7731         if (ndr_flags & NDR_SCALARS) {
7732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7733                 if (_level != level) {
7734                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7735                 }
7736                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7737                 switch (level) {
7738                         case 0: {
7739                                 uint32_t _ptr_info0;
7740                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7741                                 if (_ptr_info0) {
7742                                         NDR_PULL_ALLOC(ndr, r->info0);
7743                                 } else {
7744                                         r->info0 = NULL;
7745                                 }
7746                         break; }
7747
7748                         case 1: {
7749                                 uint32_t _ptr_info1;
7750                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7751                                 if (_ptr_info1) {
7752                                         NDR_PULL_ALLOC(ndr, r->info1);
7753                                 } else {
7754                                         r->info1 = NULL;
7755                                 }
7756                         break; }
7757
7758                         case 2: {
7759                                 uint32_t _ptr_info2;
7760                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7761                                 if (_ptr_info2) {
7762                                         NDR_PULL_ALLOC(ndr, r->info2);
7763                                 } else {
7764                                         r->info2 = NULL;
7765                                 }
7766                         break; }
7767
7768                         case 3: {
7769                                 uint32_t _ptr_info3;
7770                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7771                                 if (_ptr_info3) {
7772                                         NDR_PULL_ALLOC(ndr, r->info3);
7773                                 } else {
7774                                         r->info3 = NULL;
7775                                 }
7776                         break; }
7777
7778                         case 4: {
7779                                 uint32_t _ptr_info4;
7780                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7781                                 if (_ptr_info4) {
7782                                         NDR_PULL_ALLOC(ndr, r->info4);
7783                                 } else {
7784                                         r->info4 = NULL;
7785                                 }
7786                         break; }
7787
7788                         case 5: {
7789                                 uint32_t _ptr_info5;
7790                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7791                                 if (_ptr_info5) {
7792                                         NDR_PULL_ALLOC(ndr, r->info5);
7793                                 } else {
7794                                         r->info5 = NULL;
7795                                 }
7796                         break; }
7797
7798                         case 6: {
7799                                 uint32_t _ptr_info6;
7800                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7801                                 if (_ptr_info6) {
7802                                         NDR_PULL_ALLOC(ndr, r->info6);
7803                                 } else {
7804                                         r->info6 = NULL;
7805                                 }
7806                         break; }
7807
7808                         case 7: {
7809                                 uint32_t _ptr_info7;
7810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7811                                 if (_ptr_info7) {
7812                                         NDR_PULL_ALLOC(ndr, r->info7);
7813                                 } else {
7814                                         r->info7 = NULL;
7815                                 }
7816                         break; }
7817
7818                         case 8: {
7819                                 uint32_t _ptr_info8;
7820                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7821                                 if (_ptr_info8) {
7822                                         NDR_PULL_ALLOC(ndr, r->info8);
7823                                 } else {
7824                                         r->info8 = NULL;
7825                                 }
7826                         break; }
7827
7828                         case 9: {
7829                                 uint32_t _ptr_info9;
7830                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7831                                 if (_ptr_info9) {
7832                                         NDR_PULL_ALLOC(ndr, r->info9);
7833                                 } else {
7834                                         r->info9 = NULL;
7835                                 }
7836                         break; }
7837
7838                         default: {
7839                         break; }
7840
7841                 }
7842         }
7843         if (ndr_flags & NDR_BUFFERS) {
7844                 switch (level) {
7845                         case 0:
7846                                 if (r->info0) {
7847                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7848                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7849                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7850                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7851                                 }
7852                         break;
7853
7854                         case 1:
7855                                 if (r->info1) {
7856                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7857                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7858                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7859                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7860                                 }
7861                         break;
7862
7863                         case 2:
7864                                 if (r->info2) {
7865                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7866                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7867                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7868                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7869                                 }
7870                         break;
7871
7872                         case 3:
7873                                 if (r->info3) {
7874                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7876                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7877                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7878                                 }
7879                         break;
7880
7881                         case 4:
7882                                 if (r->info4) {
7883                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7885                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7886                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7887                                 }
7888                         break;
7889
7890                         case 5:
7891                                 if (r->info5) {
7892                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7893                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7894                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7895                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7896                                 }
7897                         break;
7898
7899                         case 6:
7900                                 if (r->info6) {
7901                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7902                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7903                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7904                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7905                                 }
7906                         break;
7907
7908                         case 7:
7909                                 if (r->info7) {
7910                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7911                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7912                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7913                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7914                                 }
7915                         break;
7916
7917                         case 8:
7918                                 if (r->info8) {
7919                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7921                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo8(ndr, NDR_SCALARS, r->info8));
7922                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7923                                 }
7924                         break;
7925
7926                         case 9:
7927                                 if (r->info9) {
7928                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7929                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7930                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo9(ndr, NDR_SCALARS, r->info9));
7931                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7932                                 }
7933                         break;
7934
7935                         default:
7936                         break;
7937
7938                 }
7939         }
7940         return NDR_ERR_SUCCESS;
7941 }
7942
7943 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7944 {
7945         int level;
7946         level = ndr_print_get_switch_value(ndr, r);
7947         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7948         switch (level) {
7949                 case 0:
7950                         ndr_print_ptr(ndr, "info0", r->info0);
7951                         ndr->depth++;
7952                         if (r->info0) {
7953                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7954                         }
7955                         ndr->depth--;
7956                 break;
7957
7958                 case 1:
7959                         ndr_print_ptr(ndr, "info1", r->info1);
7960                         ndr->depth++;
7961                         if (r->info1) {
7962                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7963                         }
7964                         ndr->depth--;
7965                 break;
7966
7967                 case 2:
7968                         ndr_print_ptr(ndr, "info2", r->info2);
7969                         ndr->depth++;
7970                         if (r->info2) {
7971                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7972                         }
7973                         ndr->depth--;
7974                 break;
7975
7976                 case 3:
7977                         ndr_print_ptr(ndr, "info3", r->info3);
7978                         ndr->depth++;
7979                         if (r->info3) {
7980                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7981                         }
7982                         ndr->depth--;
7983                 break;
7984
7985                 case 4:
7986                         ndr_print_ptr(ndr, "info4", r->info4);
7987                         ndr->depth++;
7988                         if (r->info4) {
7989                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7990                         }
7991                         ndr->depth--;
7992                 break;
7993
7994                 case 5:
7995                         ndr_print_ptr(ndr, "info5", r->info5);
7996                         ndr->depth++;
7997                         if (r->info5) {
7998                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7999                         }
8000                         ndr->depth--;
8001                 break;
8002
8003                 case 6:
8004                         ndr_print_ptr(ndr, "info6", r->info6);
8005                         ndr->depth++;
8006                         if (r->info6) {
8007                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
8008                         }
8009                         ndr->depth--;
8010                 break;
8011
8012                 case 7:
8013                         ndr_print_ptr(ndr, "info7", r->info7);
8014                         ndr->depth++;
8015                         if (r->info7) {
8016                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
8017                         }
8018                         ndr->depth--;
8019                 break;
8020
8021                 case 8:
8022                         ndr_print_ptr(ndr, "info8", r->info8);
8023                         ndr->depth++;
8024                         if (r->info8) {
8025                                 ndr_print_spoolss_SetPrinterInfo8(ndr, "info8", r->info8);
8026                         }
8027                         ndr->depth--;
8028                 break;
8029
8030                 case 9:
8031                         ndr_print_ptr(ndr, "info9", r->info9);
8032                         ndr->depth++;
8033                         if (r->info9) {
8034                                 ndr_print_spoolss_SetPrinterInfo9(ndr, "info9", r->info9);
8035                         }
8036                         ndr->depth--;
8037                 break;
8038
8039                 default:
8040                 break;
8041
8042         }
8043 }
8044
8045 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
8046 {
8047         if (ndr_flags & NDR_SCALARS) {
8048                 NDR_CHECK(ndr_push_align(ndr, 5));
8049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8050                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8051                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8052                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8053         }
8054         if (ndr_flags & NDR_BUFFERS) {
8055                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8056         }
8057         return NDR_ERR_SUCCESS;
8058 }
8059
8060 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
8061 {
8062         if (ndr_flags & NDR_SCALARS) {
8063                 NDR_CHECK(ndr_pull_align(ndr, 5));
8064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8065                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8066                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
8067                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8068         }
8069         if (ndr_flags & NDR_BUFFERS) {
8070                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
8071         }
8072         return NDR_ERR_SUCCESS;
8073 }
8074
8075 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
8076 {
8077         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
8078         ndr->depth++;
8079         ndr_print_uint32(ndr, "level", r->level);
8080         ndr_print_set_switch_value(ndr, &r->info, r->level);
8081         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
8082         ndr->depth--;
8083 }
8084
8085 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
8086 {
8087         if (ndr_flags & NDR_SCALARS) {
8088                 NDR_CHECK(ndr_push_align(ndr, 4));
8089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
8090                 {
8091                         uint32_t _flags_save_string_array = ndr->flags;
8092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8093                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
8094                         ndr->flags = _flags_save_string_array;
8095                 }
8096                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8097         }
8098         if (ndr_flags & NDR_BUFFERS) {
8099         }
8100         return NDR_ERR_SUCCESS;
8101 }
8102
8103 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
8104 {
8105         if (ndr_flags & NDR_SCALARS) {
8106                 NDR_CHECK(ndr_pull_align(ndr, 4));
8107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
8108                 {
8109                         uint32_t _flags_save_string_array = ndr->flags;
8110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8111                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
8112                         ndr->flags = _flags_save_string_array;
8113                 }
8114                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8115         }
8116         if (ndr_flags & NDR_BUFFERS) {
8117         }
8118         return NDR_ERR_SUCCESS;
8119 }
8120
8121 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
8122 {
8123         ndr_print_struct(ndr, name, "spoolss_StringArray");
8124         ndr->depth++;
8125         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);
8126         ndr_print_string_array(ndr, "string", r->string);
8127         ndr->depth--;
8128 }
8129
8130 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
8131 {
8132         if (ndr_flags & NDR_SCALARS) {
8133                 NDR_CHECK(ndr_push_align(ndr, 5));
8134                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8135                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8136         }
8137         if (ndr_flags & NDR_BUFFERS) {
8138                 if (r->driver_name) {
8139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8141                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8142                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8143                 }
8144         }
8145         return NDR_ERR_SUCCESS;
8146 }
8147
8148 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
8149 {
8150         uint32_t _ptr_driver_name;
8151         TALLOC_CTX *_mem_save_driver_name_0;
8152         if (ndr_flags & NDR_SCALARS) {
8153                 NDR_CHECK(ndr_pull_align(ndr, 5));
8154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8155                 if (_ptr_driver_name) {
8156                         NDR_PULL_ALLOC(ndr, r->driver_name);
8157                 } else {
8158                         r->driver_name = NULL;
8159                 }
8160                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8161         }
8162         if (ndr_flags & NDR_BUFFERS) {
8163                 if (r->driver_name) {
8164                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8165                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8166                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8167                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8168                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8169                                 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));
8170                         }
8171                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8172                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8174                 }
8175         }
8176         return NDR_ERR_SUCCESS;
8177 }
8178
8179 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
8180 {
8181         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
8182         ndr->depth++;
8183         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8184         ndr->depth++;
8185         if (r->driver_name) {
8186                 ndr_print_string(ndr, "driver_name", r->driver_name);
8187         }
8188         ndr->depth--;
8189         ndr->depth--;
8190 }
8191
8192 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
8193 {
8194         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
8195         return NDR_ERR_SUCCESS;
8196 }
8197
8198 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
8199 {
8200         uint32_t v;
8201         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
8202         *r = v;
8203         return NDR_ERR_SUCCESS;
8204 }
8205
8206 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
8207 {
8208         const char *val = NULL;
8209
8210         switch (r) {
8211                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
8212                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
8213                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
8214                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
8215         }
8216         ndr_print_enum(ndr, name, "ENUM", val, r);
8217 }
8218
8219 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
8220 {
8221         if (ndr_flags & NDR_SCALARS) {
8222                 NDR_CHECK(ndr_push_align(ndr, 5));
8223                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8224                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8225                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8227                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8229                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8230         }
8231         if (ndr_flags & NDR_BUFFERS) {
8232                 if (r->driver_name) {
8233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8235                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8236                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8237                 }
8238                 if (r->architecture) {
8239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8240                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8242                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8243                 }
8244                 if (r->driver_path) {
8245                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8248                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8249                 }
8250                 if (r->data_file) {
8251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8254                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8255                 }
8256                 if (r->config_file) {
8257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8260                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8261                 }
8262         }
8263         return NDR_ERR_SUCCESS;
8264 }
8265
8266 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
8267 {
8268         uint32_t _ptr_driver_name;
8269         TALLOC_CTX *_mem_save_driver_name_0;
8270         uint32_t _ptr_architecture;
8271         TALLOC_CTX *_mem_save_architecture_0;
8272         uint32_t _ptr_driver_path;
8273         TALLOC_CTX *_mem_save_driver_path_0;
8274         uint32_t _ptr_data_file;
8275         TALLOC_CTX *_mem_save_data_file_0;
8276         uint32_t _ptr_config_file;
8277         TALLOC_CTX *_mem_save_config_file_0;
8278         if (ndr_flags & NDR_SCALARS) {
8279                 NDR_CHECK(ndr_pull_align(ndr, 5));
8280                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8282                 if (_ptr_driver_name) {
8283                         NDR_PULL_ALLOC(ndr, r->driver_name);
8284                 } else {
8285                         r->driver_name = NULL;
8286                 }
8287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8288                 if (_ptr_architecture) {
8289                         NDR_PULL_ALLOC(ndr, r->architecture);
8290                 } else {
8291                         r->architecture = NULL;
8292                 }
8293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8294                 if (_ptr_driver_path) {
8295                         NDR_PULL_ALLOC(ndr, r->driver_path);
8296                 } else {
8297                         r->driver_path = NULL;
8298                 }
8299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8300                 if (_ptr_data_file) {
8301                         NDR_PULL_ALLOC(ndr, r->data_file);
8302                 } else {
8303                         r->data_file = NULL;
8304                 }
8305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8306                 if (_ptr_config_file) {
8307                         NDR_PULL_ALLOC(ndr, r->config_file);
8308                 } else {
8309                         r->config_file = NULL;
8310                 }
8311                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8312         }
8313         if (ndr_flags & NDR_BUFFERS) {
8314                 if (r->driver_name) {
8315                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8316                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8319                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8320                                 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));
8321                         }
8322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8325                 }
8326                 if (r->architecture) {
8327                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8328                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8331                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8332                                 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));
8333                         }
8334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8337                 }
8338                 if (r->driver_path) {
8339                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8340                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8343                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8344                                 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));
8345                         }
8346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8349                 }
8350                 if (r->data_file) {
8351                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8352                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8353                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8354                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8355                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8356                                 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));
8357                         }
8358                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8359                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8361                 }
8362                 if (r->config_file) {
8363                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8364                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8367                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8368                                 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));
8369                         }
8370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8373                 }
8374         }
8375         return NDR_ERR_SUCCESS;
8376 }
8377
8378 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
8379 {
8380         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
8381         ndr->depth++;
8382         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8383         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8384         ndr->depth++;
8385         if (r->driver_name) {
8386                 ndr_print_string(ndr, "driver_name", r->driver_name);
8387         }
8388         ndr->depth--;
8389         ndr_print_ptr(ndr, "architecture", r->architecture);
8390         ndr->depth++;
8391         if (r->architecture) {
8392                 ndr_print_string(ndr, "architecture", r->architecture);
8393         }
8394         ndr->depth--;
8395         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8396         ndr->depth++;
8397         if (r->driver_path) {
8398                 ndr_print_string(ndr, "driver_path", r->driver_path);
8399         }
8400         ndr->depth--;
8401         ndr_print_ptr(ndr, "data_file", r->data_file);
8402         ndr->depth++;
8403         if (r->data_file) {
8404                 ndr_print_string(ndr, "data_file", r->data_file);
8405         }
8406         ndr->depth--;
8407         ndr_print_ptr(ndr, "config_file", r->config_file);
8408         ndr->depth++;
8409         if (r->config_file) {
8410                 ndr_print_string(ndr, "config_file", r->config_file);
8411         }
8412         ndr->depth--;
8413         ndr->depth--;
8414 }
8415
8416 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
8417 {
8418         if (ndr_flags & NDR_SCALARS) {
8419                 NDR_CHECK(ndr_push_align(ndr, 5));
8420                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8424                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8431                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8432         }
8433         if (ndr_flags & NDR_BUFFERS) {
8434                 if (r->driver_name) {
8435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8437                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8439                 }
8440                 if (r->architecture) {
8441                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8443                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8445                 }
8446                 if (r->driver_path) {
8447                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8449                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8451                 }
8452                 if (r->data_file) {
8453                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8455                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8457                 }
8458                 if (r->config_file) {
8459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8461                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8463                 }
8464                 if (r->help_file) {
8465                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8467                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8469                 }
8470                 if (r->monitor_name) {
8471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8473                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8474                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8475                 }
8476                 if (r->default_datatype) {
8477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8479                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8480                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8481                 }
8482                 if (r->dependent_files) {
8483                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8484                 }
8485         }
8486         return NDR_ERR_SUCCESS;
8487 }
8488
8489 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
8490 {
8491         uint32_t _ptr_driver_name;
8492         TALLOC_CTX *_mem_save_driver_name_0;
8493         uint32_t _ptr_architecture;
8494         TALLOC_CTX *_mem_save_architecture_0;
8495         uint32_t _ptr_driver_path;
8496         TALLOC_CTX *_mem_save_driver_path_0;
8497         uint32_t _ptr_data_file;
8498         TALLOC_CTX *_mem_save_data_file_0;
8499         uint32_t _ptr_config_file;
8500         TALLOC_CTX *_mem_save_config_file_0;
8501         uint32_t _ptr_help_file;
8502         TALLOC_CTX *_mem_save_help_file_0;
8503         uint32_t _ptr_monitor_name;
8504         TALLOC_CTX *_mem_save_monitor_name_0;
8505         uint32_t _ptr_default_datatype;
8506         TALLOC_CTX *_mem_save_default_datatype_0;
8507         uint32_t _ptr_dependent_files;
8508         TALLOC_CTX *_mem_save_dependent_files_0;
8509         if (ndr_flags & NDR_SCALARS) {
8510                 NDR_CHECK(ndr_pull_align(ndr, 5));
8511                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8513                 if (_ptr_driver_name) {
8514                         NDR_PULL_ALLOC(ndr, r->driver_name);
8515                 } else {
8516                         r->driver_name = NULL;
8517                 }
8518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8519                 if (_ptr_architecture) {
8520                         NDR_PULL_ALLOC(ndr, r->architecture);
8521                 } else {
8522                         r->architecture = NULL;
8523                 }
8524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8525                 if (_ptr_driver_path) {
8526                         NDR_PULL_ALLOC(ndr, r->driver_path);
8527                 } else {
8528                         r->driver_path = NULL;
8529                 }
8530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8531                 if (_ptr_data_file) {
8532                         NDR_PULL_ALLOC(ndr, r->data_file);
8533                 } else {
8534                         r->data_file = NULL;
8535                 }
8536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8537                 if (_ptr_config_file) {
8538                         NDR_PULL_ALLOC(ndr, r->config_file);
8539                 } else {
8540                         r->config_file = NULL;
8541                 }
8542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8543                 if (_ptr_help_file) {
8544                         NDR_PULL_ALLOC(ndr, r->help_file);
8545                 } else {
8546                         r->help_file = NULL;
8547                 }
8548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8549                 if (_ptr_monitor_name) {
8550                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8551                 } else {
8552                         r->monitor_name = NULL;
8553                 }
8554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8555                 if (_ptr_default_datatype) {
8556                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8557                 } else {
8558                         r->default_datatype = NULL;
8559                 }
8560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8562                 if (_ptr_dependent_files) {
8563                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8564                 } else {
8565                         r->dependent_files = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8568         }
8569         if (ndr_flags & NDR_BUFFERS) {
8570                 if (r->driver_name) {
8571                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8572                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8573                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8574                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8575                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8576                                 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));
8577                         }
8578                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8579                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8581                 }
8582                 if (r->architecture) {
8583                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8584                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8585                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8586                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8587                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8588                                 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));
8589                         }
8590                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8591                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8593                 }
8594                 if (r->driver_path) {
8595                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8596                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8597                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8598                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8599                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8600                                 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));
8601                         }
8602                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8603                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8605                 }
8606                 if (r->data_file) {
8607                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8608                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8609                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8610                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8611                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8612                                 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));
8613                         }
8614                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8615                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8616                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8617                 }
8618                 if (r->config_file) {
8619                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8620                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8621                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8622                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8623                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8624                                 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));
8625                         }
8626                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8627                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8629                 }
8630                 if (r->help_file) {
8631                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8632                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8635                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8636                                 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));
8637                         }
8638                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8639                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8641                 }
8642                 if (r->monitor_name) {
8643                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8644                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8647                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8648                                 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));
8649                         }
8650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8653                 }
8654                 if (r->default_datatype) {
8655                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8656                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8657                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8658                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8659                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8660                                 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));
8661                         }
8662                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8663                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8665                 }
8666                 if (r->dependent_files) {
8667                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8668                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8669                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8671                 }
8672         }
8673         return NDR_ERR_SUCCESS;
8674 }
8675
8676 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
8677 {
8678         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
8679         ndr->depth++;
8680         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8681         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8682         ndr->depth++;
8683         if (r->driver_name) {
8684                 ndr_print_string(ndr, "driver_name", r->driver_name);
8685         }
8686         ndr->depth--;
8687         ndr_print_ptr(ndr, "architecture", r->architecture);
8688         ndr->depth++;
8689         if (r->architecture) {
8690                 ndr_print_string(ndr, "architecture", r->architecture);
8691         }
8692         ndr->depth--;
8693         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8694         ndr->depth++;
8695         if (r->driver_path) {
8696                 ndr_print_string(ndr, "driver_path", r->driver_path);
8697         }
8698         ndr->depth--;
8699         ndr_print_ptr(ndr, "data_file", r->data_file);
8700         ndr->depth++;
8701         if (r->data_file) {
8702                 ndr_print_string(ndr, "data_file", r->data_file);
8703         }
8704         ndr->depth--;
8705         ndr_print_ptr(ndr, "config_file", r->config_file);
8706         ndr->depth++;
8707         if (r->config_file) {
8708                 ndr_print_string(ndr, "config_file", r->config_file);
8709         }
8710         ndr->depth--;
8711         ndr_print_ptr(ndr, "help_file", r->help_file);
8712         ndr->depth++;
8713         if (r->help_file) {
8714                 ndr_print_string(ndr, "help_file", r->help_file);
8715         }
8716         ndr->depth--;
8717         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8718         ndr->depth++;
8719         if (r->monitor_name) {
8720                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8721         }
8722         ndr->depth--;
8723         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8724         ndr->depth++;
8725         if (r->default_datatype) {
8726                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8727         }
8728         ndr->depth--;
8729         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);
8730         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8731         ndr->depth++;
8732         if (r->dependent_files) {
8733                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8734         }
8735         ndr->depth--;
8736         ndr->depth--;
8737 }
8738
8739 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8740 {
8741         if (ndr_flags & NDR_SCALARS) {
8742                 NDR_CHECK(ndr_push_align(ndr, 5));
8743                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8756                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8757         }
8758         if (ndr_flags & NDR_BUFFERS) {
8759                 if (r->driver_name) {
8760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8761                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8764                 }
8765                 if (r->architecture) {
8766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8767                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8770                 }
8771                 if (r->driver_path) {
8772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8773                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8775                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8776                 }
8777                 if (r->data_file) {
8778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8781                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8782                 }
8783                 if (r->config_file) {
8784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8787                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8788                 }
8789                 if (r->help_file) {
8790                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8792                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8794                 }
8795                 if (r->monitor_name) {
8796                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8797                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8798                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8799                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8800                 }
8801                 if (r->default_datatype) {
8802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8806                 }
8807                 if (r->dependent_files) {
8808                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8809                 }
8810                 if (r->previous_names) {
8811                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8812                 }
8813         }
8814         return NDR_ERR_SUCCESS;
8815 }
8816
8817 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8818 {
8819         uint32_t _ptr_driver_name;
8820         TALLOC_CTX *_mem_save_driver_name_0;
8821         uint32_t _ptr_architecture;
8822         TALLOC_CTX *_mem_save_architecture_0;
8823         uint32_t _ptr_driver_path;
8824         TALLOC_CTX *_mem_save_driver_path_0;
8825         uint32_t _ptr_data_file;
8826         TALLOC_CTX *_mem_save_data_file_0;
8827         uint32_t _ptr_config_file;
8828         TALLOC_CTX *_mem_save_config_file_0;
8829         uint32_t _ptr_help_file;
8830         TALLOC_CTX *_mem_save_help_file_0;
8831         uint32_t _ptr_monitor_name;
8832         TALLOC_CTX *_mem_save_monitor_name_0;
8833         uint32_t _ptr_default_datatype;
8834         TALLOC_CTX *_mem_save_default_datatype_0;
8835         uint32_t _ptr_dependent_files;
8836         TALLOC_CTX *_mem_save_dependent_files_0;
8837         uint32_t _ptr_previous_names;
8838         TALLOC_CTX *_mem_save_previous_names_0;
8839         if (ndr_flags & NDR_SCALARS) {
8840                 NDR_CHECK(ndr_pull_align(ndr, 5));
8841                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8843                 if (_ptr_driver_name) {
8844                         NDR_PULL_ALLOC(ndr, r->driver_name);
8845                 } else {
8846                         r->driver_name = NULL;
8847                 }
8848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8849                 if (_ptr_architecture) {
8850                         NDR_PULL_ALLOC(ndr, r->architecture);
8851                 } else {
8852                         r->architecture = NULL;
8853                 }
8854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8855                 if (_ptr_driver_path) {
8856                         NDR_PULL_ALLOC(ndr, r->driver_path);
8857                 } else {
8858                         r->driver_path = NULL;
8859                 }
8860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8861                 if (_ptr_data_file) {
8862                         NDR_PULL_ALLOC(ndr, r->data_file);
8863                 } else {
8864                         r->data_file = NULL;
8865                 }
8866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8867                 if (_ptr_config_file) {
8868                         NDR_PULL_ALLOC(ndr, r->config_file);
8869                 } else {
8870                         r->config_file = NULL;
8871                 }
8872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8873                 if (_ptr_help_file) {
8874                         NDR_PULL_ALLOC(ndr, r->help_file);
8875                 } else {
8876                         r->help_file = NULL;
8877                 }
8878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8879                 if (_ptr_monitor_name) {
8880                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8881                 } else {
8882                         r->monitor_name = NULL;
8883                 }
8884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8885                 if (_ptr_default_datatype) {
8886                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8887                 } else {
8888                         r->default_datatype = NULL;
8889                 }
8890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8892                 if (_ptr_dependent_files) {
8893                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8894                 } else {
8895                         r->dependent_files = NULL;
8896                 }
8897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8899                 if (_ptr_previous_names) {
8900                         NDR_PULL_ALLOC(ndr, r->previous_names);
8901                 } else {
8902                         r->previous_names = NULL;
8903                 }
8904                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8905         }
8906         if (ndr_flags & NDR_BUFFERS) {
8907                 if (r->driver_name) {
8908                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8909                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8911                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8912                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8913                                 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));
8914                         }
8915                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8916                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8918                 }
8919                 if (r->architecture) {
8920                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8921                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8924                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8925                                 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));
8926                         }
8927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8930                 }
8931                 if (r->driver_path) {
8932                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8933                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8936                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8937                                 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));
8938                         }
8939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8940                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8942                 }
8943                 if (r->data_file) {
8944                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8945                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8948                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8949                                 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));
8950                         }
8951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8954                 }
8955                 if (r->config_file) {
8956                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8957                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8960                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8961                                 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));
8962                         }
8963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8966                 }
8967                 if (r->help_file) {
8968                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8969                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8972                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8973                                 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));
8974                         }
8975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8978                 }
8979                 if (r->monitor_name) {
8980                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8981                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8984                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8985                                 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));
8986                         }
8987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8990                 }
8991                 if (r->default_datatype) {
8992                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8993                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8994                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8995                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8996                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8997                                 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));
8998                         }
8999                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9000                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9001                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9002                 }
9003                 if (r->dependent_files) {
9004                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9005                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9006                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9008                 }
9009                 if (r->previous_names) {
9010                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9011                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9012                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9014                 }
9015         }
9016         return NDR_ERR_SUCCESS;
9017 }
9018
9019 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
9020 {
9021         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
9022         ndr->depth++;
9023         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9024         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9025         ndr->depth++;
9026         if (r->driver_name) {
9027                 ndr_print_string(ndr, "driver_name", r->driver_name);
9028         }
9029         ndr->depth--;
9030         ndr_print_ptr(ndr, "architecture", r->architecture);
9031         ndr->depth++;
9032         if (r->architecture) {
9033                 ndr_print_string(ndr, "architecture", r->architecture);
9034         }
9035         ndr->depth--;
9036         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9037         ndr->depth++;
9038         if (r->driver_path) {
9039                 ndr_print_string(ndr, "driver_path", r->driver_path);
9040         }
9041         ndr->depth--;
9042         ndr_print_ptr(ndr, "data_file", r->data_file);
9043         ndr->depth++;
9044         if (r->data_file) {
9045                 ndr_print_string(ndr, "data_file", r->data_file);
9046         }
9047         ndr->depth--;
9048         ndr_print_ptr(ndr, "config_file", r->config_file);
9049         ndr->depth++;
9050         if (r->config_file) {
9051                 ndr_print_string(ndr, "config_file", r->config_file);
9052         }
9053         ndr->depth--;
9054         ndr_print_ptr(ndr, "help_file", r->help_file);
9055         ndr->depth++;
9056         if (r->help_file) {
9057                 ndr_print_string(ndr, "help_file", r->help_file);
9058         }
9059         ndr->depth--;
9060         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9061         ndr->depth++;
9062         if (r->monitor_name) {
9063                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9064         }
9065         ndr->depth--;
9066         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9067         ndr->depth++;
9068         if (r->default_datatype) {
9069                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9070         }
9071         ndr->depth--;
9072         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);
9073         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9074         ndr->depth++;
9075         if (r->dependent_files) {
9076                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9077         }
9078         ndr->depth--;
9079         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);
9080         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9081         ndr->depth++;
9082         if (r->previous_names) {
9083                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9084         }
9085         ndr->depth--;
9086         ndr->depth--;
9087 }
9088
9089 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9090 {
9091         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9092         return NDR_ERR_SUCCESS;
9093 }
9094
9095 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9096 {
9097         uint32_t v;
9098         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9099         *r = v;
9100         return NDR_ERR_SUCCESS;
9101 }
9102
9103 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
9104 {
9105         ndr_print_uint32(ndr, name, r);
9106         ndr->depth++;
9107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
9108         ndr->depth--;
9109 }
9110
9111 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
9112 {
9113         if (ndr_flags & NDR_SCALARS) {
9114                 NDR_CHECK(ndr_push_align(ndr, 8));
9115                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9128                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9129                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9133                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9134                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9135         }
9136         if (ndr_flags & NDR_BUFFERS) {
9137                 if (r->driver_name) {
9138                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9139                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9140                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9141                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9142                 }
9143                 if (r->architecture) {
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9146                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9148                 }
9149                 if (r->driver_path) {
9150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9151                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9152                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9154                 }
9155                 if (r->data_file) {
9156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9158                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9160                 }
9161                 if (r->config_file) {
9162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9163                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9166                 }
9167                 if (r->help_file) {
9168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9171                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9172                 }
9173                 if (r->monitor_name) {
9174                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9175                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9177                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9178                 }
9179                 if (r->default_datatype) {
9180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9184                 }
9185                 if (r->dependent_files) {
9186                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9187                 }
9188                 if (r->previous_names) {
9189                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9190                 }
9191                 if (r->manufacturer_name) {
9192                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9195                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9196                 }
9197                 if (r->manufacturer_url) {
9198                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9201                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9202                 }
9203                 if (r->hardware_id) {
9204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9207                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9208                 }
9209                 if (r->provider) {
9210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9213                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9214                 }
9215         }
9216         return NDR_ERR_SUCCESS;
9217 }
9218
9219 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
9220 {
9221         uint32_t _ptr_driver_name;
9222         TALLOC_CTX *_mem_save_driver_name_0;
9223         uint32_t _ptr_architecture;
9224         TALLOC_CTX *_mem_save_architecture_0;
9225         uint32_t _ptr_driver_path;
9226         TALLOC_CTX *_mem_save_driver_path_0;
9227         uint32_t _ptr_data_file;
9228         TALLOC_CTX *_mem_save_data_file_0;
9229         uint32_t _ptr_config_file;
9230         TALLOC_CTX *_mem_save_config_file_0;
9231         uint32_t _ptr_help_file;
9232         TALLOC_CTX *_mem_save_help_file_0;
9233         uint32_t _ptr_monitor_name;
9234         TALLOC_CTX *_mem_save_monitor_name_0;
9235         uint32_t _ptr_default_datatype;
9236         TALLOC_CTX *_mem_save_default_datatype_0;
9237         uint32_t _ptr_dependent_files;
9238         TALLOC_CTX *_mem_save_dependent_files_0;
9239         uint32_t _ptr_previous_names;
9240         TALLOC_CTX *_mem_save_previous_names_0;
9241         uint32_t _ptr_manufacturer_name;
9242         TALLOC_CTX *_mem_save_manufacturer_name_0;
9243         uint32_t _ptr_manufacturer_url;
9244         TALLOC_CTX *_mem_save_manufacturer_url_0;
9245         uint32_t _ptr_hardware_id;
9246         TALLOC_CTX *_mem_save_hardware_id_0;
9247         uint32_t _ptr_provider;
9248         TALLOC_CTX *_mem_save_provider_0;
9249         if (ndr_flags & NDR_SCALARS) {
9250                 NDR_CHECK(ndr_pull_align(ndr, 8));
9251                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9253                 if (_ptr_driver_name) {
9254                         NDR_PULL_ALLOC(ndr, r->driver_name);
9255                 } else {
9256                         r->driver_name = NULL;
9257                 }
9258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9259                 if (_ptr_architecture) {
9260                         NDR_PULL_ALLOC(ndr, r->architecture);
9261                 } else {
9262                         r->architecture = NULL;
9263                 }
9264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9265                 if (_ptr_driver_path) {
9266                         NDR_PULL_ALLOC(ndr, r->driver_path);
9267                 } else {
9268                         r->driver_path = NULL;
9269                 }
9270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9271                 if (_ptr_data_file) {
9272                         NDR_PULL_ALLOC(ndr, r->data_file);
9273                 } else {
9274                         r->data_file = NULL;
9275                 }
9276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9277                 if (_ptr_config_file) {
9278                         NDR_PULL_ALLOC(ndr, r->config_file);
9279                 } else {
9280                         r->config_file = NULL;
9281                 }
9282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9283                 if (_ptr_help_file) {
9284                         NDR_PULL_ALLOC(ndr, r->help_file);
9285                 } else {
9286                         r->help_file = NULL;
9287                 }
9288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9289                 if (_ptr_monitor_name) {
9290                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9291                 } else {
9292                         r->monitor_name = NULL;
9293                 }
9294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9295                 if (_ptr_default_datatype) {
9296                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9297                 } else {
9298                         r->default_datatype = NULL;
9299                 }
9300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9301                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9302                 if (_ptr_dependent_files) {
9303                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9304                 } else {
9305                         r->dependent_files = NULL;
9306                 }
9307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9309                 if (_ptr_previous_names) {
9310                         NDR_PULL_ALLOC(ndr, r->previous_names);
9311                 } else {
9312                         r->previous_names = NULL;
9313                 }
9314                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9315                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9317                 if (_ptr_manufacturer_name) {
9318                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9319                 } else {
9320                         r->manufacturer_name = NULL;
9321                 }
9322                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9323                 if (_ptr_manufacturer_url) {
9324                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9325                 } else {
9326                         r->manufacturer_url = NULL;
9327                 }
9328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9329                 if (_ptr_hardware_id) {
9330                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9331                 } else {
9332                         r->hardware_id = NULL;
9333                 }
9334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9335                 if (_ptr_provider) {
9336                         NDR_PULL_ALLOC(ndr, r->provider);
9337                 } else {
9338                         r->provider = NULL;
9339                 }
9340                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9341         }
9342         if (ndr_flags & NDR_BUFFERS) {
9343                 if (r->driver_name) {
9344                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9345                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9346                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9347                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9348                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9349                                 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));
9350                         }
9351                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9352                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9353                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9354                 }
9355                 if (r->architecture) {
9356                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9357                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9358                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9359                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9360                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9361                                 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));
9362                         }
9363                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9364                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9365                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9366                 }
9367                 if (r->driver_path) {
9368                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9369                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9371                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9372                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9373                                 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));
9374                         }
9375                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9376                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9377                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9378                 }
9379                 if (r->data_file) {
9380                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9381                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9382                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9383                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9384                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9385                                 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));
9386                         }
9387                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9388                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9390                 }
9391                 if (r->config_file) {
9392                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9393                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9395                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9396                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9397                                 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));
9398                         }
9399                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9400                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9402                 }
9403                 if (r->help_file) {
9404                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9405                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9408                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9409                                 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));
9410                         }
9411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9414                 }
9415                 if (r->monitor_name) {
9416                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9417                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9418                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9419                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9420                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9421                                 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));
9422                         }
9423                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9424                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9426                 }
9427                 if (r->default_datatype) {
9428                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9429                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9431                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9432                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9433                                 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));
9434                         }
9435                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9436                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9438                 }
9439                 if (r->dependent_files) {
9440                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9441                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9442                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9444                 }
9445                 if (r->previous_names) {
9446                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9447                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9448                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9450                 }
9451                 if (r->manufacturer_name) {
9452                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9453                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9455                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9456                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9457                                 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));
9458                         }
9459                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9460                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9462                 }
9463                 if (r->manufacturer_url) {
9464                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9465                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9466                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9467                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9468                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9469                                 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));
9470                         }
9471                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9472                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9474                 }
9475                 if (r->hardware_id) {
9476                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9477                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9478                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9479                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9480                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9481                                 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));
9482                         }
9483                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9484                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9486                 }
9487                 if (r->provider) {
9488                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9489                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9490                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9491                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9492                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9493                                 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));
9494                         }
9495                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9496                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9498                 }
9499         }
9500         return NDR_ERR_SUCCESS;
9501 }
9502
9503 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
9504 {
9505         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
9506         ndr->depth++;
9507         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9508         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9509         ndr->depth++;
9510         if (r->driver_name) {
9511                 ndr_print_string(ndr, "driver_name", r->driver_name);
9512         }
9513         ndr->depth--;
9514         ndr_print_ptr(ndr, "architecture", r->architecture);
9515         ndr->depth++;
9516         if (r->architecture) {
9517                 ndr_print_string(ndr, "architecture", r->architecture);
9518         }
9519         ndr->depth--;
9520         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9521         ndr->depth++;
9522         if (r->driver_path) {
9523                 ndr_print_string(ndr, "driver_path", r->driver_path);
9524         }
9525         ndr->depth--;
9526         ndr_print_ptr(ndr, "data_file", r->data_file);
9527         ndr->depth++;
9528         if (r->data_file) {
9529                 ndr_print_string(ndr, "data_file", r->data_file);
9530         }
9531         ndr->depth--;
9532         ndr_print_ptr(ndr, "config_file", r->config_file);
9533         ndr->depth++;
9534         if (r->config_file) {
9535                 ndr_print_string(ndr, "config_file", r->config_file);
9536         }
9537         ndr->depth--;
9538         ndr_print_ptr(ndr, "help_file", r->help_file);
9539         ndr->depth++;
9540         if (r->help_file) {
9541                 ndr_print_string(ndr, "help_file", r->help_file);
9542         }
9543         ndr->depth--;
9544         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9545         ndr->depth++;
9546         if (r->monitor_name) {
9547                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9548         }
9549         ndr->depth--;
9550         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9551         ndr->depth++;
9552         if (r->default_datatype) {
9553                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9554         }
9555         ndr->depth--;
9556         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);
9557         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9558         ndr->depth++;
9559         if (r->dependent_files) {
9560                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9561         }
9562         ndr->depth--;
9563         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);
9564         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9565         ndr->depth++;
9566         if (r->previous_names) {
9567                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9568         }
9569         ndr->depth--;
9570         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9571         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9572         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9573         ndr->depth++;
9574         if (r->manufacturer_name) {
9575                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9576         }
9577         ndr->depth--;
9578         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9579         ndr->depth++;
9580         if (r->manufacturer_url) {
9581                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9582         }
9583         ndr->depth--;
9584         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9585         ndr->depth++;
9586         if (r->hardware_id) {
9587                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9588         }
9589         ndr->depth--;
9590         ndr_print_ptr(ndr, "provider", r->provider);
9591         ndr->depth++;
9592         if (r->provider) {
9593                 ndr_print_string(ndr, "provider", r->provider);
9594         }
9595         ndr->depth--;
9596         ndr->depth--;
9597 }
9598
9599 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
9600 {
9601         if (ndr_flags & NDR_SCALARS) {
9602                 NDR_CHECK(ndr_push_align(ndr, 8));
9603                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
9605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
9606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
9607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
9608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
9609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
9610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
9611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
9612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9613                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
9614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
9616                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
9617                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
9618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
9619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
9620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
9621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
9622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
9623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
9624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9625                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
9626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
9627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
9628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
9629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
9630                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
9631                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
9632                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9633         }
9634         if (ndr_flags & NDR_BUFFERS) {
9635                 if (r->driver_name) {
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9638                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
9639                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9640                 }
9641                 if (r->architecture) {
9642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
9645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9646                 }
9647                 if (r->driver_path) {
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
9651                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9652                 }
9653                 if (r->data_file) {
9654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
9657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9658                 }
9659                 if (r->config_file) {
9660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9661                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9662                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
9663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9664                 }
9665                 if (r->help_file) {
9666                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9667                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9668                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
9669                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9670                 }
9671                 if (r->monitor_name) {
9672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
9675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9676                 }
9677                 if (r->default_datatype) {
9678                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
9681                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9682                 }
9683                 if (r->dependent_files) {
9684                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9685                 }
9686                 if (r->previous_names) {
9687                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9688                 }
9689                 if (r->manufacturer_name) {
9690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
9693                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9694                 }
9695                 if (r->manufacturer_url) {
9696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
9699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9700                 }
9701                 if (r->hardware_id) {
9702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
9705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9706                 }
9707                 if (r->provider) {
9708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9711                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9712                 }
9713                 if (r->print_processor) {
9714                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9718                 }
9719                 if (r->vendor_setup) {
9720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9723                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9724                 }
9725                 if (r->color_profiles) {
9726                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9727                 }
9728                 if (r->inf_path) {
9729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9730                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9731                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9733                 }
9734                 if (r->core_driver_dependencies) {
9735                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9736                 }
9737         }
9738         return NDR_ERR_SUCCESS;
9739 }
9740
9741 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9742 {
9743         uint32_t _ptr_driver_name;
9744         TALLOC_CTX *_mem_save_driver_name_0;
9745         uint32_t _ptr_architecture;
9746         TALLOC_CTX *_mem_save_architecture_0;
9747         uint32_t _ptr_driver_path;
9748         TALLOC_CTX *_mem_save_driver_path_0;
9749         uint32_t _ptr_data_file;
9750         TALLOC_CTX *_mem_save_data_file_0;
9751         uint32_t _ptr_config_file;
9752         TALLOC_CTX *_mem_save_config_file_0;
9753         uint32_t _ptr_help_file;
9754         TALLOC_CTX *_mem_save_help_file_0;
9755         uint32_t _ptr_monitor_name;
9756         TALLOC_CTX *_mem_save_monitor_name_0;
9757         uint32_t _ptr_default_datatype;
9758         TALLOC_CTX *_mem_save_default_datatype_0;
9759         uint32_t _ptr_dependent_files;
9760         TALLOC_CTX *_mem_save_dependent_files_0;
9761         uint32_t _ptr_previous_names;
9762         TALLOC_CTX *_mem_save_previous_names_0;
9763         uint32_t _ptr_manufacturer_name;
9764         TALLOC_CTX *_mem_save_manufacturer_name_0;
9765         uint32_t _ptr_manufacturer_url;
9766         TALLOC_CTX *_mem_save_manufacturer_url_0;
9767         uint32_t _ptr_hardware_id;
9768         TALLOC_CTX *_mem_save_hardware_id_0;
9769         uint32_t _ptr_provider;
9770         TALLOC_CTX *_mem_save_provider_0;
9771         uint32_t _ptr_print_processor;
9772         TALLOC_CTX *_mem_save_print_processor_0;
9773         uint32_t _ptr_vendor_setup;
9774         TALLOC_CTX *_mem_save_vendor_setup_0;
9775         uint32_t _ptr_color_profiles;
9776         TALLOC_CTX *_mem_save_color_profiles_0;
9777         uint32_t _ptr_inf_path;
9778         TALLOC_CTX *_mem_save_inf_path_0;
9779         uint32_t _ptr_core_driver_dependencies;
9780         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9781         if (ndr_flags & NDR_SCALARS) {
9782                 NDR_CHECK(ndr_pull_align(ndr, 8));
9783                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9785                 if (_ptr_driver_name) {
9786                         NDR_PULL_ALLOC(ndr, r->driver_name);
9787                 } else {
9788                         r->driver_name = NULL;
9789                 }
9790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9791                 if (_ptr_architecture) {
9792                         NDR_PULL_ALLOC(ndr, r->architecture);
9793                 } else {
9794                         r->architecture = NULL;
9795                 }
9796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9797                 if (_ptr_driver_path) {
9798                         NDR_PULL_ALLOC(ndr, r->driver_path);
9799                 } else {
9800                         r->driver_path = NULL;
9801                 }
9802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9803                 if (_ptr_data_file) {
9804                         NDR_PULL_ALLOC(ndr, r->data_file);
9805                 } else {
9806                         r->data_file = NULL;
9807                 }
9808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9809                 if (_ptr_config_file) {
9810                         NDR_PULL_ALLOC(ndr, r->config_file);
9811                 } else {
9812                         r->config_file = NULL;
9813                 }
9814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9815                 if (_ptr_help_file) {
9816                         NDR_PULL_ALLOC(ndr, r->help_file);
9817                 } else {
9818                         r->help_file = NULL;
9819                 }
9820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9821                 if (_ptr_monitor_name) {
9822                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9823                 } else {
9824                         r->monitor_name = NULL;
9825                 }
9826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9827                 if (_ptr_default_datatype) {
9828                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9829                 } else {
9830                         r->default_datatype = NULL;
9831                 }
9832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9834                 if (_ptr_dependent_files) {
9835                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9836                 } else {
9837                         r->dependent_files = NULL;
9838                 }
9839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9841                 if (_ptr_previous_names) {
9842                         NDR_PULL_ALLOC(ndr, r->previous_names);
9843                 } else {
9844                         r->previous_names = NULL;
9845                 }
9846                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9847                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9849                 if (_ptr_manufacturer_name) {
9850                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9851                 } else {
9852                         r->manufacturer_name = NULL;
9853                 }
9854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9855                 if (_ptr_manufacturer_url) {
9856                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9857                 } else {
9858                         r->manufacturer_url = NULL;
9859                 }
9860                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9861                 if (_ptr_hardware_id) {
9862                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9863                 } else {
9864                         r->hardware_id = NULL;
9865                 }
9866                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9867                 if (_ptr_provider) {
9868                         NDR_PULL_ALLOC(ndr, r->provider);
9869                 } else {
9870                         r->provider = NULL;
9871                 }
9872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9873                 if (_ptr_print_processor) {
9874                         NDR_PULL_ALLOC(ndr, r->print_processor);
9875                 } else {
9876                         r->print_processor = NULL;
9877                 }
9878                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9879                 if (_ptr_vendor_setup) {
9880                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9881                 } else {
9882                         r->vendor_setup = NULL;
9883                 }
9884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9886                 if (_ptr_color_profiles) {
9887                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9888                 } else {
9889                         r->color_profiles = NULL;
9890                 }
9891                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9892                 if (_ptr_inf_path) {
9893                         NDR_PULL_ALLOC(ndr, r->inf_path);
9894                 } else {
9895                         r->inf_path = NULL;
9896                 }
9897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9900                 if (_ptr_core_driver_dependencies) {
9901                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9902                 } else {
9903                         r->core_driver_dependencies = NULL;
9904                 }
9905                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9906                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9907                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9908         }
9909         if (ndr_flags & NDR_BUFFERS) {
9910                 if (r->driver_name) {
9911                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9912                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9915                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9916                                 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));
9917                         }
9918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9921                 }
9922                 if (r->architecture) {
9923                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9924                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9925                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9926                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9927                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9928                                 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));
9929                         }
9930                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9931                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9933                 }
9934                 if (r->driver_path) {
9935                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9936                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9937                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9938                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9939                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9940                                 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));
9941                         }
9942                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9945                 }
9946                 if (r->data_file) {
9947                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9948                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9949                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9950                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9951                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9952                                 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));
9953                         }
9954                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9955                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9957                 }
9958                 if (r->config_file) {
9959                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9960                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9962                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9963                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9964                                 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));
9965                         }
9966                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9967                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9969                 }
9970                 if (r->help_file) {
9971                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9972                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9975                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9976                                 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));
9977                         }
9978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9981                 }
9982                 if (r->monitor_name) {
9983                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9984                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9987                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9988                                 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));
9989                         }
9990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9991                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9993                 }
9994                 if (r->default_datatype) {
9995                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9996                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9999                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
10000                                 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));
10001                         }
10002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
10003                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
10004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10005                 }
10006                 if (r->dependent_files) {
10007                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10008                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10009                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
10010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10011                 }
10012                 if (r->previous_names) {
10013                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10014                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10015                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
10016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10017                 }
10018                 if (r->manufacturer_name) {
10019                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10021                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
10022                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
10023                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
10024                                 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));
10025                         }
10026                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
10027                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
10028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10029                 }
10030                 if (r->manufacturer_url) {
10031                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10032                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
10034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
10035                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
10036                                 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));
10037                         }
10038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
10039                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
10040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10041                 }
10042                 if (r->hardware_id) {
10043                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10044                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
10046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
10047                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
10048                                 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));
10049                         }
10050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
10051                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
10052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10053                 }
10054                 if (r->provider) {
10055                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10056                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
10058                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
10059                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
10060                                 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));
10061                         }
10062                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
10063                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
10064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10065                 }
10066                 if (r->print_processor) {
10067                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
10068                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
10069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
10070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
10071                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
10072                                 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));
10073                         }
10074                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
10075                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
10076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
10077                 }
10078                 if (r->vendor_setup) {
10079                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
10081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
10082                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
10083                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
10084                                 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));
10085                         }
10086                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
10087                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
10088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
10089                 }
10090                 if (r->color_profiles) {
10091                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
10092                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
10093                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
10094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
10095                 }
10096                 if (r->inf_path) {
10097                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10098                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
10099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
10100                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
10101                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
10102                                 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));
10103                         }
10104                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
10105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
10106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
10107                 }
10108                 if (r->core_driver_dependencies) {
10109                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
10110                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
10111                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
10112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
10113                 }
10114         }
10115         return NDR_ERR_SUCCESS;
10116 }
10117
10118 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
10119 {
10120         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
10121         ndr->depth++;
10122         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10123         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10124         ndr->depth++;
10125         if (r->driver_name) {
10126                 ndr_print_string(ndr, "driver_name", r->driver_name);
10127         }
10128         ndr->depth--;
10129         ndr_print_ptr(ndr, "architecture", r->architecture);
10130         ndr->depth++;
10131         if (r->architecture) {
10132                 ndr_print_string(ndr, "architecture", r->architecture);
10133         }
10134         ndr->depth--;
10135         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10136         ndr->depth++;
10137         if (r->driver_path) {
10138                 ndr_print_string(ndr, "driver_path", r->driver_path);
10139         }
10140         ndr->depth--;
10141         ndr_print_ptr(ndr, "data_file", r->data_file);
10142         ndr->depth++;
10143         if (r->data_file) {
10144                 ndr_print_string(ndr, "data_file", r->data_file);
10145         }
10146         ndr->depth--;
10147         ndr_print_ptr(ndr, "config_file", r->config_file);
10148         ndr->depth++;
10149         if (r->config_file) {
10150                 ndr_print_string(ndr, "config_file", r->config_file);
10151         }
10152         ndr->depth--;
10153         ndr_print_ptr(ndr, "help_file", r->help_file);
10154         ndr->depth++;
10155         if (r->help_file) {
10156                 ndr_print_string(ndr, "help_file", r->help_file);
10157         }
10158         ndr->depth--;
10159         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10160         ndr->depth++;
10161         if (r->monitor_name) {
10162                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10163         }
10164         ndr->depth--;
10165         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10166         ndr->depth++;
10167         if (r->default_datatype) {
10168                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10169         }
10170         ndr->depth--;
10171         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);
10172         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10173         ndr->depth++;
10174         if (r->dependent_files) {
10175                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
10176         }
10177         ndr->depth--;
10178         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);
10179         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10180         ndr->depth++;
10181         if (r->previous_names) {
10182                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
10183         }
10184         ndr->depth--;
10185         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10186         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10187         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10188         ndr->depth++;
10189         if (r->manufacturer_name) {
10190                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10191         }
10192         ndr->depth--;
10193         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10194         ndr->depth++;
10195         if (r->manufacturer_url) {
10196                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10197         }
10198         ndr->depth--;
10199         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10200         ndr->depth++;
10201         if (r->hardware_id) {
10202                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10203         }
10204         ndr->depth--;
10205         ndr_print_ptr(ndr, "provider", r->provider);
10206         ndr->depth++;
10207         if (r->provider) {
10208                 ndr_print_string(ndr, "provider", r->provider);
10209         }
10210         ndr->depth--;
10211         ndr_print_ptr(ndr, "print_processor", r->print_processor);
10212         ndr->depth++;
10213         if (r->print_processor) {
10214                 ndr_print_string(ndr, "print_processor", r->print_processor);
10215         }
10216         ndr->depth--;
10217         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
10218         ndr->depth++;
10219         if (r->vendor_setup) {
10220                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
10221         }
10222         ndr->depth--;
10223         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);
10224         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
10225         ndr->depth++;
10226         if (r->color_profiles) {
10227                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
10228         }
10229         ndr->depth--;
10230         ndr_print_ptr(ndr, "inf_path", r->inf_path);
10231         ndr->depth++;
10232         if (r->inf_path) {
10233                 ndr_print_string(ndr, "inf_path", r->inf_path);
10234         }
10235         ndr->depth--;
10236         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
10237         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);
10238         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10239         ndr->depth++;
10240         if (r->core_driver_dependencies) {
10241                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
10242         }
10243         ndr->depth--;
10244         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
10245         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
10246         ndr->depth--;
10247 }
10248
10249 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
10250 {
10251         if (ndr_flags & NDR_SCALARS) {
10252                 int level = ndr_push_get_switch_value(ndr, r);
10253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
10254                 NDR_CHECK(ndr_push_union_align(ndr, 5));
10255                 switch (level) {
10256                         case 1: {
10257                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
10258                         break; }
10259
10260                         case 2: {
10261                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
10262                         break; }
10263
10264                         case 3: {
10265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
10266                         break; }
10267
10268                         case 4: {
10269                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
10270                         break; }
10271
10272                         case 6: {
10273                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
10274                         break; }
10275
10276                         case 8: {
10277                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
10278                         break; }
10279
10280                         default:
10281                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10282                 }
10283         }
10284         if (ndr_flags & NDR_BUFFERS) {
10285                 int level = ndr_push_get_switch_value(ndr, r);
10286                 switch (level) {
10287                         case 1:
10288                                 if (r->info1) {
10289                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10290                                 }
10291                         break;
10292
10293                         case 2:
10294                                 if (r->info2) {
10295                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10296                                 }
10297                         break;
10298
10299                         case 3:
10300                                 if (r->info3) {
10301                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10302                                 }
10303                         break;
10304
10305                         case 4:
10306                                 if (r->info4) {
10307                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10308                                 }
10309                         break;
10310
10311                         case 6:
10312                                 if (r->info6) {
10313                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10314                                 }
10315                         break;
10316
10317                         case 8:
10318                                 if (r->info8) {
10319                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10320                                 }
10321                         break;
10322
10323                         default:
10324                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10325                 }
10326         }
10327         return NDR_ERR_SUCCESS;
10328 }
10329
10330 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
10331 {
10332         int level;
10333         uint32_t _level;
10334         TALLOC_CTX *_mem_save_info1_0;
10335         TALLOC_CTX *_mem_save_info2_0;
10336         TALLOC_CTX *_mem_save_info3_0;
10337         TALLOC_CTX *_mem_save_info4_0;
10338         TALLOC_CTX *_mem_save_info6_0;
10339         TALLOC_CTX *_mem_save_info8_0;
10340         level = ndr_pull_get_switch_value(ndr, r);
10341         if (ndr_flags & NDR_SCALARS) {
10342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
10343                 if (_level != level) {
10344                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10345                 }
10346                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
10347                 switch (level) {
10348                         case 1: {
10349                                 uint32_t _ptr_info1;
10350                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
10351                                 if (_ptr_info1) {
10352                                         NDR_PULL_ALLOC(ndr, r->info1);
10353                                 } else {
10354                                         r->info1 = NULL;
10355                                 }
10356                         break; }
10357
10358                         case 2: {
10359                                 uint32_t _ptr_info2;
10360                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
10361                                 if (_ptr_info2) {
10362                                         NDR_PULL_ALLOC(ndr, r->info2);
10363                                 } else {
10364                                         r->info2 = NULL;
10365                                 }
10366                         break; }
10367
10368                         case 3: {
10369                                 uint32_t _ptr_info3;
10370                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
10371                                 if (_ptr_info3) {
10372                                         NDR_PULL_ALLOC(ndr, r->info3);
10373                                 } else {
10374                                         r->info3 = NULL;
10375                                 }
10376                         break; }
10377
10378                         case 4: {
10379                                 uint32_t _ptr_info4;
10380                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
10381                                 if (_ptr_info4) {
10382                                         NDR_PULL_ALLOC(ndr, r->info4);
10383                                 } else {
10384                                         r->info4 = NULL;
10385                                 }
10386                         break; }
10387
10388                         case 6: {
10389                                 uint32_t _ptr_info6;
10390                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
10391                                 if (_ptr_info6) {
10392                                         NDR_PULL_ALLOC(ndr, r->info6);
10393                                 } else {
10394                                         r->info6 = NULL;
10395                                 }
10396                         break; }
10397
10398                         case 8: {
10399                                 uint32_t _ptr_info8;
10400                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
10401                                 if (_ptr_info8) {
10402                                         NDR_PULL_ALLOC(ndr, r->info8);
10403                                 } else {
10404                                         r->info8 = NULL;
10405                                 }
10406                         break; }
10407
10408                         default:
10409                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10410                 }
10411         }
10412         if (ndr_flags & NDR_BUFFERS) {
10413                 switch (level) {
10414                         case 1:
10415                                 if (r->info1) {
10416                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
10417                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
10418                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
10419                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
10420                                 }
10421                         break;
10422
10423                         case 2:
10424                                 if (r->info2) {
10425                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
10426                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
10427                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
10428                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
10429                                 }
10430                         break;
10431
10432                         case 3:
10433                                 if (r->info3) {
10434                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
10435                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
10436                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
10437                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
10438                                 }
10439                         break;
10440
10441                         case 4:
10442                                 if (r->info4) {
10443                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
10444                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
10445                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
10446                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
10447                                 }
10448                         break;
10449
10450                         case 6:
10451                                 if (r->info6) {
10452                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
10453                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
10454                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
10455                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
10456                                 }
10457                         break;
10458
10459                         case 8:
10460                                 if (r->info8) {
10461                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
10462                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
10463                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
10464                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
10465                                 }
10466                         break;
10467
10468                         default:
10469                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10470                 }
10471         }
10472         return NDR_ERR_SUCCESS;
10473 }
10474
10475 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
10476 {
10477         int level;
10478         level = ndr_print_get_switch_value(ndr, r);
10479         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
10480         switch (level) {
10481                 case 1:
10482                         ndr_print_ptr(ndr, "info1", r->info1);
10483                         ndr->depth++;
10484                         if (r->info1) {
10485                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
10486                         }
10487                         ndr->depth--;
10488                 break;
10489
10490                 case 2:
10491                         ndr_print_ptr(ndr, "info2", r->info2);
10492                         ndr->depth++;
10493                         if (r->info2) {
10494                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
10495                         }
10496                         ndr->depth--;
10497                 break;
10498
10499                 case 3:
10500                         ndr_print_ptr(ndr, "info3", r->info3);
10501                         ndr->depth++;
10502                         if (r->info3) {
10503                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
10504                         }
10505                         ndr->depth--;
10506                 break;
10507
10508                 case 4:
10509                         ndr_print_ptr(ndr, "info4", r->info4);
10510                         ndr->depth++;
10511                         if (r->info4) {
10512                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
10513                         }
10514                         ndr->depth--;
10515                 break;
10516
10517                 case 6:
10518                         ndr_print_ptr(ndr, "info6", r->info6);
10519                         ndr->depth++;
10520                         if (r->info6) {
10521                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
10522                         }
10523                         ndr->depth--;
10524                 break;
10525
10526                 case 8:
10527                         ndr_print_ptr(ndr, "info8", r->info8);
10528                         ndr->depth++;
10529                         if (r->info8) {
10530                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
10531                         }
10532                         ndr->depth--;
10533                 break;
10534
10535                 default:
10536                         ndr_print_bad_level(ndr, name, level);
10537         }
10538 }
10539
10540 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
10541 {
10542         if (ndr_flags & NDR_SCALARS) {
10543                 NDR_CHECK(ndr_push_align(ndr, 5));
10544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
10545                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
10546                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10547                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10548         }
10549         if (ndr_flags & NDR_BUFFERS) {
10550                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10551         }
10552         return NDR_ERR_SUCCESS;
10553 }
10554
10555 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
10556 {
10557         if (ndr_flags & NDR_SCALARS) {
10558                 NDR_CHECK(ndr_pull_align(ndr, 5));
10559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
10560                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
10561                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
10562                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10563         }
10564         if (ndr_flags & NDR_BUFFERS) {
10565                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
10566         }
10567         return NDR_ERR_SUCCESS;
10568 }
10569
10570 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
10571 {
10572         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
10573         ndr->depth++;
10574         ndr_print_uint32(ndr, "level", r->level);
10575         ndr_print_set_switch_value(ndr, &r->info, r->level);
10576         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
10577         ndr->depth--;
10578 }
10579
10580 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
10581 {
10582         if (ndr_flags & NDR_SCALARS) {
10583                 NDR_CHECK(ndr_push_align(ndr, 5));
10584                 {
10585                         uint32_t _flags_save_string = ndr->flags;
10586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10588                         ndr->flags = _flags_save_string;
10589                 }
10590                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10591         }
10592         if (ndr_flags & NDR_BUFFERS) {
10593                 {
10594                         uint32_t _flags_save_string = ndr->flags;
10595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10596                         if (r->driver_name) {
10597                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10598                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10599                         }
10600                         ndr->flags = _flags_save_string;
10601                 }
10602         }
10603         return NDR_ERR_SUCCESS;
10604 }
10605
10606 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
10607 {
10608         uint32_t _ptr_driver_name;
10609         TALLOC_CTX *_mem_save_driver_name_0;
10610         if (ndr_flags & NDR_SCALARS) {
10611                 NDR_CHECK(ndr_pull_align(ndr, 5));
10612                 {
10613                         uint32_t _flags_save_string = ndr->flags;
10614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10615                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10616                         if (_ptr_driver_name) {
10617                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10618                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10619                         } else {
10620                                 r->driver_name = NULL;
10621                         }
10622                         ndr->flags = _flags_save_string;
10623                 }
10624                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10625         }
10626         if (ndr_flags & NDR_BUFFERS) {
10627                 {
10628                         uint32_t _flags_save_string = ndr->flags;
10629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10630                         if (r->driver_name) {
10631                                 uint32_t _relative_save_offset;
10632                                 _relative_save_offset = ndr->offset;
10633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10634                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10635                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10636                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10637                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10638                                 if (ndr->offset > ndr->relative_highest_offset) {
10639                                         ndr->relative_highest_offset = ndr->offset;
10640                                 }
10641                                 ndr->offset = _relative_save_offset;
10642                         }
10643                         ndr->flags = _flags_save_string;
10644                 }
10645         }
10646         return NDR_ERR_SUCCESS;
10647 }
10648
10649 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
10650 {
10651         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
10652         ndr->depth++;
10653         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10654         ndr->depth++;
10655         if (r->driver_name) {
10656                 ndr_print_string(ndr, "driver_name", r->driver_name);
10657         }
10658         ndr->depth--;
10659         ndr->depth--;
10660 }
10661
10662 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
10663 {
10664         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
10665 }
10666
10667 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
10668 {
10669         if (ndr_flags & NDR_SCALARS) {
10670                 NDR_CHECK(ndr_push_align(ndr, 5));
10671                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10672                 {
10673                         uint32_t _flags_save_string = ndr->flags;
10674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10675                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10676                         ndr->flags = _flags_save_string;
10677                 }
10678                 {
10679                         uint32_t _flags_save_string = ndr->flags;
10680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10681                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10682                         ndr->flags = _flags_save_string;
10683                 }
10684                 {
10685                         uint32_t _flags_save_string = ndr->flags;
10686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10687                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10688                         ndr->flags = _flags_save_string;
10689                 }
10690                 {
10691                         uint32_t _flags_save_string = ndr->flags;
10692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10694                         ndr->flags = _flags_save_string;
10695                 }
10696                 {
10697                         uint32_t _flags_save_string = ndr->flags;
10698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10699                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10700                         ndr->flags = _flags_save_string;
10701                 }
10702                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10703         }
10704         if (ndr_flags & NDR_BUFFERS) {
10705                 {
10706                         uint32_t _flags_save_string = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         if (r->driver_name) {
10709                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10710                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10711                         }
10712                         ndr->flags = _flags_save_string;
10713                 }
10714                 {
10715                         uint32_t _flags_save_string = ndr->flags;
10716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10717                         if (r->architecture) {
10718                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10719                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10720                         }
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         if (r->driver_path) {
10727                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10728                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10729                         }
10730                         ndr->flags = _flags_save_string;
10731                 }
10732                 {
10733                         uint32_t _flags_save_string = ndr->flags;
10734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10735                         if (r->data_file) {
10736                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10737                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10738                         }
10739                         ndr->flags = _flags_save_string;
10740                 }
10741                 {
10742                         uint32_t _flags_save_string = ndr->flags;
10743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10744                         if (r->config_file) {
10745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10746                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10747                         }
10748                         ndr->flags = _flags_save_string;
10749                 }
10750         }
10751         return NDR_ERR_SUCCESS;
10752 }
10753
10754 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10755 {
10756         uint32_t _ptr_driver_name;
10757         TALLOC_CTX *_mem_save_driver_name_0;
10758         uint32_t _ptr_architecture;
10759         TALLOC_CTX *_mem_save_architecture_0;
10760         uint32_t _ptr_driver_path;
10761         TALLOC_CTX *_mem_save_driver_path_0;
10762         uint32_t _ptr_data_file;
10763         TALLOC_CTX *_mem_save_data_file_0;
10764         uint32_t _ptr_config_file;
10765         TALLOC_CTX *_mem_save_config_file_0;
10766         if (ndr_flags & NDR_SCALARS) {
10767                 NDR_CHECK(ndr_pull_align(ndr, 5));
10768                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10769                 {
10770                         uint32_t _flags_save_string = ndr->flags;
10771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10772                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10773                         if (_ptr_driver_name) {
10774                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10775                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10776                         } else {
10777                                 r->driver_name = NULL;
10778                         }
10779                         ndr->flags = _flags_save_string;
10780                 }
10781                 {
10782                         uint32_t _flags_save_string = ndr->flags;
10783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10784                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10785                         if (_ptr_architecture) {
10786                                 NDR_PULL_ALLOC(ndr, r->architecture);
10787                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10788                         } else {
10789                                 r->architecture = NULL;
10790                         }
10791                         ndr->flags = _flags_save_string;
10792                 }
10793                 {
10794                         uint32_t _flags_save_string = ndr->flags;
10795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10796                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10797                         if (_ptr_driver_path) {
10798                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10799                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10800                         } else {
10801                                 r->driver_path = NULL;
10802                         }
10803                         ndr->flags = _flags_save_string;
10804                 }
10805                 {
10806                         uint32_t _flags_save_string = ndr->flags;
10807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10808                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10809                         if (_ptr_data_file) {
10810                                 NDR_PULL_ALLOC(ndr, r->data_file);
10811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10812                         } else {
10813                                 r->data_file = NULL;
10814                         }
10815                         ndr->flags = _flags_save_string;
10816                 }
10817                 {
10818                         uint32_t _flags_save_string = ndr->flags;
10819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10820                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10821                         if (_ptr_config_file) {
10822                                 NDR_PULL_ALLOC(ndr, r->config_file);
10823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10824                         } else {
10825                                 r->config_file = NULL;
10826                         }
10827                         ndr->flags = _flags_save_string;
10828                 }
10829                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10830         }
10831         if (ndr_flags & NDR_BUFFERS) {
10832                 {
10833                         uint32_t _flags_save_string = ndr->flags;
10834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10835                         if (r->driver_name) {
10836                                 uint32_t _relative_save_offset;
10837                                 _relative_save_offset = ndr->offset;
10838                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10839                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10840                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10841                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10842                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10843                                 if (ndr->offset > ndr->relative_highest_offset) {
10844                                         ndr->relative_highest_offset = ndr->offset;
10845                                 }
10846                                 ndr->offset = _relative_save_offset;
10847                         }
10848                         ndr->flags = _flags_save_string;
10849                 }
10850                 {
10851                         uint32_t _flags_save_string = ndr->flags;
10852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10853                         if (r->architecture) {
10854                                 uint32_t _relative_save_offset;
10855                                 _relative_save_offset = ndr->offset;
10856                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10857                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10858                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10859                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10860                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10861                                 if (ndr->offset > ndr->relative_highest_offset) {
10862                                         ndr->relative_highest_offset = ndr->offset;
10863                                 }
10864                                 ndr->offset = _relative_save_offset;
10865                         }
10866                         ndr->flags = _flags_save_string;
10867                 }
10868                 {
10869                         uint32_t _flags_save_string = ndr->flags;
10870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10871                         if (r->driver_path) {
10872                                 uint32_t _relative_save_offset;
10873                                 _relative_save_offset = ndr->offset;
10874                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10875                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10876                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10877                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10878                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10879                                 if (ndr->offset > ndr->relative_highest_offset) {
10880                                         ndr->relative_highest_offset = ndr->offset;
10881                                 }
10882                                 ndr->offset = _relative_save_offset;
10883                         }
10884                         ndr->flags = _flags_save_string;
10885                 }
10886                 {
10887                         uint32_t _flags_save_string = ndr->flags;
10888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10889                         if (r->data_file) {
10890                                 uint32_t _relative_save_offset;
10891                                 _relative_save_offset = ndr->offset;
10892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10893                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10894                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10897                                 if (ndr->offset > ndr->relative_highest_offset) {
10898                                         ndr->relative_highest_offset = ndr->offset;
10899                                 }
10900                                 ndr->offset = _relative_save_offset;
10901                         }
10902                         ndr->flags = _flags_save_string;
10903                 }
10904                 {
10905                         uint32_t _flags_save_string = ndr->flags;
10906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10907                         if (r->config_file) {
10908                                 uint32_t _relative_save_offset;
10909                                 _relative_save_offset = ndr->offset;
10910                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10911                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10912                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10913                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10915                                 if (ndr->offset > ndr->relative_highest_offset) {
10916                                         ndr->relative_highest_offset = ndr->offset;
10917                                 }
10918                                 ndr->offset = _relative_save_offset;
10919                         }
10920                         ndr->flags = _flags_save_string;
10921                 }
10922         }
10923         return NDR_ERR_SUCCESS;
10924 }
10925
10926 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10927 {
10928         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10929         ndr->depth++;
10930         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10931         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10932         ndr->depth++;
10933         if (r->driver_name) {
10934                 ndr_print_string(ndr, "driver_name", r->driver_name);
10935         }
10936         ndr->depth--;
10937         ndr_print_ptr(ndr, "architecture", r->architecture);
10938         ndr->depth++;
10939         if (r->architecture) {
10940                 ndr_print_string(ndr, "architecture", r->architecture);
10941         }
10942         ndr->depth--;
10943         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10944         ndr->depth++;
10945         if (r->driver_path) {
10946                 ndr_print_string(ndr, "driver_path", r->driver_path);
10947         }
10948         ndr->depth--;
10949         ndr_print_ptr(ndr, "data_file", r->data_file);
10950         ndr->depth++;
10951         if (r->data_file) {
10952                 ndr_print_string(ndr, "data_file", r->data_file);
10953         }
10954         ndr->depth--;
10955         ndr_print_ptr(ndr, "config_file", r->config_file);
10956         ndr->depth++;
10957         if (r->config_file) {
10958                 ndr_print_string(ndr, "config_file", r->config_file);
10959         }
10960         ndr->depth--;
10961         ndr->depth--;
10962 }
10963
10964 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10965 {
10966         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10967 }
10968
10969 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10970 {
10971         if (ndr_flags & NDR_SCALARS) {
10972                 NDR_CHECK(ndr_push_align(ndr, 5));
10973                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10974                 {
10975                         uint32_t _flags_save_string = ndr->flags;
10976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10977                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10978                         ndr->flags = _flags_save_string;
10979                 }
10980                 {
10981                         uint32_t _flags_save_string = ndr->flags;
10982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10983                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10984                         ndr->flags = _flags_save_string;
10985                 }
10986                 {
10987                         uint32_t _flags_save_string = ndr->flags;
10988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10996                         ndr->flags = _flags_save_string;
10997                 }
10998                 {
10999                         uint32_t _flags_save_string = ndr->flags;
11000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11002                         ndr->flags = _flags_save_string;
11003                 }
11004                 {
11005                         uint32_t _flags_save_string = ndr->flags;
11006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11008                         ndr->flags = _flags_save_string;
11009                 }
11010                 {
11011                         uint32_t _flags_save_string_array = ndr->flags;
11012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11014                         ndr->flags = _flags_save_string_array;
11015                 }
11016                 {
11017                         uint32_t _flags_save_string = ndr->flags;
11018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11020                         ndr->flags = _flags_save_string;
11021                 }
11022                 {
11023                         uint32_t _flags_save_string = ndr->flags;
11024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11026                         ndr->flags = _flags_save_string;
11027                 }
11028                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11029         }
11030         if (ndr_flags & NDR_BUFFERS) {
11031                 {
11032                         uint32_t _flags_save_string = ndr->flags;
11033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11034                         if (r->driver_name) {
11035                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11036                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11037                         }
11038                         ndr->flags = _flags_save_string;
11039                 }
11040                 {
11041                         uint32_t _flags_save_string = ndr->flags;
11042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11043                         if (r->architecture) {
11044                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11045                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11046                         }
11047                         ndr->flags = _flags_save_string;
11048                 }
11049                 {
11050                         uint32_t _flags_save_string = ndr->flags;
11051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11052                         if (r->driver_path) {
11053                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11055                         }
11056                         ndr->flags = _flags_save_string;
11057                 }
11058                 {
11059                         uint32_t _flags_save_string = ndr->flags;
11060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11061                         if (r->data_file) {
11062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11064                         }
11065                         ndr->flags = _flags_save_string;
11066                 }
11067                 {
11068                         uint32_t _flags_save_string = ndr->flags;
11069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11070                         if (r->config_file) {
11071                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11072                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11073                         }
11074                         ndr->flags = _flags_save_string;
11075                 }
11076                 {
11077                         uint32_t _flags_save_string = ndr->flags;
11078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11079                         if (r->help_file) {
11080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11082                         }
11083                         ndr->flags = _flags_save_string;
11084                 }
11085                 {
11086                         uint32_t _flags_save_string_array = ndr->flags;
11087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11088                         if (r->dependent_files) {
11089                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11090                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11091                         }
11092                         ndr->flags = _flags_save_string_array;
11093                 }
11094                 {
11095                         uint32_t _flags_save_string = ndr->flags;
11096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11097                         if (r->monitor_name) {
11098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11100                         }
11101                         ndr->flags = _flags_save_string;
11102                 }
11103                 {
11104                         uint32_t _flags_save_string = ndr->flags;
11105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11106                         if (r->default_datatype) {
11107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11108                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11109                         }
11110                         ndr->flags = _flags_save_string;
11111                 }
11112         }
11113         return NDR_ERR_SUCCESS;
11114 }
11115
11116 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
11117 {
11118         uint32_t _ptr_driver_name;
11119         TALLOC_CTX *_mem_save_driver_name_0;
11120         uint32_t _ptr_architecture;
11121         TALLOC_CTX *_mem_save_architecture_0;
11122         uint32_t _ptr_driver_path;
11123         TALLOC_CTX *_mem_save_driver_path_0;
11124         uint32_t _ptr_data_file;
11125         TALLOC_CTX *_mem_save_data_file_0;
11126         uint32_t _ptr_config_file;
11127         TALLOC_CTX *_mem_save_config_file_0;
11128         uint32_t _ptr_help_file;
11129         TALLOC_CTX *_mem_save_help_file_0;
11130         uint32_t _ptr_dependent_files;
11131         TALLOC_CTX *_mem_save_dependent_files_0;
11132         uint32_t _ptr_monitor_name;
11133         TALLOC_CTX *_mem_save_monitor_name_0;
11134         uint32_t _ptr_default_datatype;
11135         TALLOC_CTX *_mem_save_default_datatype_0;
11136         if (ndr_flags & NDR_SCALARS) {
11137                 NDR_CHECK(ndr_pull_align(ndr, 5));
11138                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11139                 {
11140                         uint32_t _flags_save_string = ndr->flags;
11141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11143                         if (_ptr_driver_name) {
11144                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11146                         } else {
11147                                 r->driver_name = NULL;
11148                         }
11149                         ndr->flags = _flags_save_string;
11150                 }
11151                 {
11152                         uint32_t _flags_save_string = ndr->flags;
11153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11155                         if (_ptr_architecture) {
11156                                 NDR_PULL_ALLOC(ndr, r->architecture);
11157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11158                         } else {
11159                                 r->architecture = NULL;
11160                         }
11161                         ndr->flags = _flags_save_string;
11162                 }
11163                 {
11164                         uint32_t _flags_save_string = ndr->flags;
11165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11167                         if (_ptr_driver_path) {
11168                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11170                         } else {
11171                                 r->driver_path = NULL;
11172                         }
11173                         ndr->flags = _flags_save_string;
11174                 }
11175                 {
11176                         uint32_t _flags_save_string = ndr->flags;
11177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11179                         if (_ptr_data_file) {
11180                                 NDR_PULL_ALLOC(ndr, r->data_file);
11181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11182                         } else {
11183                                 r->data_file = NULL;
11184                         }
11185                         ndr->flags = _flags_save_string;
11186                 }
11187                 {
11188                         uint32_t _flags_save_string = ndr->flags;
11189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11191                         if (_ptr_config_file) {
11192                                 NDR_PULL_ALLOC(ndr, r->config_file);
11193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11194                         } else {
11195                                 r->config_file = NULL;
11196                         }
11197                         ndr->flags = _flags_save_string;
11198                 }
11199                 {
11200                         uint32_t _flags_save_string = ndr->flags;
11201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11202                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11203                         if (_ptr_help_file) {
11204                                 NDR_PULL_ALLOC(ndr, r->help_file);
11205                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11206                         } else {
11207                                 r->help_file = NULL;
11208                         }
11209                         ndr->flags = _flags_save_string;
11210                 }
11211                 {
11212                         uint32_t _flags_save_string_array = ndr->flags;
11213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11215                         if (_ptr_dependent_files) {
11216                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11218                         } else {
11219                                 r->dependent_files = NULL;
11220                         }
11221                         ndr->flags = _flags_save_string_array;
11222                 }
11223                 {
11224                         uint32_t _flags_save_string = ndr->flags;
11225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11226                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11227                         if (_ptr_monitor_name) {
11228                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11229                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11230                         } else {
11231                                 r->monitor_name = NULL;
11232                         }
11233                         ndr->flags = _flags_save_string;
11234                 }
11235                 {
11236                         uint32_t _flags_save_string = ndr->flags;
11237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11239                         if (_ptr_default_datatype) {
11240                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11242                         } else {
11243                                 r->default_datatype = NULL;
11244                         }
11245                         ndr->flags = _flags_save_string;
11246                 }
11247                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11248         }
11249         if (ndr_flags & NDR_BUFFERS) {
11250                 {
11251                         uint32_t _flags_save_string = ndr->flags;
11252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11253                         if (r->driver_name) {
11254                                 uint32_t _relative_save_offset;
11255                                 _relative_save_offset = ndr->offset;
11256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11257                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11258                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11259                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11261                                 if (ndr->offset > ndr->relative_highest_offset) {
11262                                         ndr->relative_highest_offset = ndr->offset;
11263                                 }
11264                                 ndr->offset = _relative_save_offset;
11265                         }
11266                         ndr->flags = _flags_save_string;
11267                 }
11268                 {
11269                         uint32_t _flags_save_string = ndr->flags;
11270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11271                         if (r->architecture) {
11272                                 uint32_t _relative_save_offset;
11273                                 _relative_save_offset = ndr->offset;
11274                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11275                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11276                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11277                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11278                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11279                                 if (ndr->offset > ndr->relative_highest_offset) {
11280                                         ndr->relative_highest_offset = ndr->offset;
11281                                 }
11282                                 ndr->offset = _relative_save_offset;
11283                         }
11284                         ndr->flags = _flags_save_string;
11285                 }
11286                 {
11287                         uint32_t _flags_save_string = ndr->flags;
11288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11289                         if (r->driver_path) {
11290                                 uint32_t _relative_save_offset;
11291                                 _relative_save_offset = ndr->offset;
11292                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11293                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11294                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11295                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11296                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11297                                 if (ndr->offset > ndr->relative_highest_offset) {
11298                                         ndr->relative_highest_offset = ndr->offset;
11299                                 }
11300                                 ndr->offset = _relative_save_offset;
11301                         }
11302                         ndr->flags = _flags_save_string;
11303                 }
11304                 {
11305                         uint32_t _flags_save_string = ndr->flags;
11306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11307                         if (r->data_file) {
11308                                 uint32_t _relative_save_offset;
11309                                 _relative_save_offset = ndr->offset;
11310                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11311                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11312                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11313                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11314                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11315                                 if (ndr->offset > ndr->relative_highest_offset) {
11316                                         ndr->relative_highest_offset = ndr->offset;
11317                                 }
11318                                 ndr->offset = _relative_save_offset;
11319                         }
11320                         ndr->flags = _flags_save_string;
11321                 }
11322                 {
11323                         uint32_t _flags_save_string = ndr->flags;
11324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11325                         if (r->config_file) {
11326                                 uint32_t _relative_save_offset;
11327                                 _relative_save_offset = ndr->offset;
11328                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11329                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11330                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11331                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11332                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11333                                 if (ndr->offset > ndr->relative_highest_offset) {
11334                                         ndr->relative_highest_offset = ndr->offset;
11335                                 }
11336                                 ndr->offset = _relative_save_offset;
11337                         }
11338                         ndr->flags = _flags_save_string;
11339                 }
11340                 {
11341                         uint32_t _flags_save_string = ndr->flags;
11342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11343                         if (r->help_file) {
11344                                 uint32_t _relative_save_offset;
11345                                 _relative_save_offset = ndr->offset;
11346                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11347                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11348                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11349                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11350                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11351                                 if (ndr->offset > ndr->relative_highest_offset) {
11352                                         ndr->relative_highest_offset = ndr->offset;
11353                                 }
11354                                 ndr->offset = _relative_save_offset;
11355                         }
11356                         ndr->flags = _flags_save_string;
11357                 }
11358                 {
11359                         uint32_t _flags_save_string_array = ndr->flags;
11360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11361                         if (r->dependent_files) {
11362                                 uint32_t _relative_save_offset;
11363                                 _relative_save_offset = ndr->offset;
11364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11365                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11366                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11367                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11369                                 if (ndr->offset > ndr->relative_highest_offset) {
11370                                         ndr->relative_highest_offset = ndr->offset;
11371                                 }
11372                                 ndr->offset = _relative_save_offset;
11373                         }
11374                         ndr->flags = _flags_save_string_array;
11375                 }
11376                 {
11377                         uint32_t _flags_save_string = ndr->flags;
11378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11379                         if (r->monitor_name) {
11380                                 uint32_t _relative_save_offset;
11381                                 _relative_save_offset = ndr->offset;
11382                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11383                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11384                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11385                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11386                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11387                                 if (ndr->offset > ndr->relative_highest_offset) {
11388                                         ndr->relative_highest_offset = ndr->offset;
11389                                 }
11390                                 ndr->offset = _relative_save_offset;
11391                         }
11392                         ndr->flags = _flags_save_string;
11393                 }
11394                 {
11395                         uint32_t _flags_save_string = ndr->flags;
11396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11397                         if (r->default_datatype) {
11398                                 uint32_t _relative_save_offset;
11399                                 _relative_save_offset = ndr->offset;
11400                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11401                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11402                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11403                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11404                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11405                                 if (ndr->offset > ndr->relative_highest_offset) {
11406                                         ndr->relative_highest_offset = ndr->offset;
11407                                 }
11408                                 ndr->offset = _relative_save_offset;
11409                         }
11410                         ndr->flags = _flags_save_string;
11411                 }
11412         }
11413         return NDR_ERR_SUCCESS;
11414 }
11415
11416 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
11417 {
11418         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
11419         ndr->depth++;
11420         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11422         ndr->depth++;
11423         if (r->driver_name) {
11424                 ndr_print_string(ndr, "driver_name", r->driver_name);
11425         }
11426         ndr->depth--;
11427         ndr_print_ptr(ndr, "architecture", r->architecture);
11428         ndr->depth++;
11429         if (r->architecture) {
11430                 ndr_print_string(ndr, "architecture", r->architecture);
11431         }
11432         ndr->depth--;
11433         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11434         ndr->depth++;
11435         if (r->driver_path) {
11436                 ndr_print_string(ndr, "driver_path", r->driver_path);
11437         }
11438         ndr->depth--;
11439         ndr_print_ptr(ndr, "data_file", r->data_file);
11440         ndr->depth++;
11441         if (r->data_file) {
11442                 ndr_print_string(ndr, "data_file", r->data_file);
11443         }
11444         ndr->depth--;
11445         ndr_print_ptr(ndr, "config_file", r->config_file);
11446         ndr->depth++;
11447         if (r->config_file) {
11448                 ndr_print_string(ndr, "config_file", r->config_file);
11449         }
11450         ndr->depth--;
11451         ndr_print_ptr(ndr, "help_file", r->help_file);
11452         ndr->depth++;
11453         if (r->help_file) {
11454                 ndr_print_string(ndr, "help_file", r->help_file);
11455         }
11456         ndr->depth--;
11457         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11458         ndr->depth++;
11459         if (r->dependent_files) {
11460                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11461         }
11462         ndr->depth--;
11463         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11464         ndr->depth++;
11465         if (r->monitor_name) {
11466                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11467         }
11468         ndr->depth--;
11469         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11470         ndr->depth++;
11471         if (r->default_datatype) {
11472                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11473         }
11474         ndr->depth--;
11475         ndr->depth--;
11476 }
11477
11478 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
11479 {
11480         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
11481 }
11482
11483 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
11484 {
11485         if (ndr_flags & NDR_SCALARS) {
11486                 NDR_CHECK(ndr_push_align(ndr, 5));
11487                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11488                 {
11489                         uint32_t _flags_save_string = ndr->flags;
11490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11491                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11492                         ndr->flags = _flags_save_string;
11493                 }
11494                 {
11495                         uint32_t _flags_save_string = ndr->flags;
11496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11497                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11498                         ndr->flags = _flags_save_string;
11499                 }
11500                 {
11501                         uint32_t _flags_save_string = ndr->flags;
11502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11503                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11504                         ndr->flags = _flags_save_string;
11505                 }
11506                 {
11507                         uint32_t _flags_save_string = ndr->flags;
11508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11509                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11510                         ndr->flags = _flags_save_string;
11511                 }
11512                 {
11513                         uint32_t _flags_save_string = ndr->flags;
11514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11515                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11516                         ndr->flags = _flags_save_string;
11517                 }
11518                 {
11519                         uint32_t _flags_save_string = ndr->flags;
11520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11521                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11522                         ndr->flags = _flags_save_string;
11523                 }
11524                 {
11525                         uint32_t _flags_save_string_array = ndr->flags;
11526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11527                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11528                         ndr->flags = _flags_save_string_array;
11529                 }
11530                 {
11531                         uint32_t _flags_save_string = ndr->flags;
11532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11533                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11534                         ndr->flags = _flags_save_string;
11535                 }
11536                 {
11537                         uint32_t _flags_save_string = ndr->flags;
11538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11539                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11540                         ndr->flags = _flags_save_string;
11541                 }
11542                 {
11543                         uint32_t _flags_save_string_array = ndr->flags;
11544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11545                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11546                         ndr->flags = _flags_save_string_array;
11547                 }
11548                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11549         }
11550         if (ndr_flags & NDR_BUFFERS) {
11551                 {
11552                         uint32_t _flags_save_string = ndr->flags;
11553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11554                         if (r->driver_name) {
11555                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11556                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11557                         }
11558                         ndr->flags = _flags_save_string;
11559                 }
11560                 {
11561                         uint32_t _flags_save_string = ndr->flags;
11562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11563                         if (r->architecture) {
11564                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11565                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11566                         }
11567                         ndr->flags = _flags_save_string;
11568                 }
11569                 {
11570                         uint32_t _flags_save_string = ndr->flags;
11571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11572                         if (r->driver_path) {
11573                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11574                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11575                         }
11576                         ndr->flags = _flags_save_string;
11577                 }
11578                 {
11579                         uint32_t _flags_save_string = ndr->flags;
11580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11581                         if (r->data_file) {
11582                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11583                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11584                         }
11585                         ndr->flags = _flags_save_string;
11586                 }
11587                 {
11588                         uint32_t _flags_save_string = ndr->flags;
11589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11590                         if (r->config_file) {
11591                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11592                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11593                         }
11594                         ndr->flags = _flags_save_string;
11595                 }
11596                 {
11597                         uint32_t _flags_save_string = ndr->flags;
11598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11599                         if (r->help_file) {
11600                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11601                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11602                         }
11603                         ndr->flags = _flags_save_string;
11604                 }
11605                 {
11606                         uint32_t _flags_save_string_array = ndr->flags;
11607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11608                         if (r->dependent_files) {
11609                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11610                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11611                         }
11612                         ndr->flags = _flags_save_string_array;
11613                 }
11614                 {
11615                         uint32_t _flags_save_string = ndr->flags;
11616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11617                         if (r->monitor_name) {
11618                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11619                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11620                         }
11621                         ndr->flags = _flags_save_string;
11622                 }
11623                 {
11624                         uint32_t _flags_save_string = ndr->flags;
11625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11626                         if (r->default_datatype) {
11627                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11628                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11629                         }
11630                         ndr->flags = _flags_save_string;
11631                 }
11632                 {
11633                         uint32_t _flags_save_string_array = ndr->flags;
11634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11635                         if (r->previous_names) {
11636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11637                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11638                         }
11639                         ndr->flags = _flags_save_string_array;
11640                 }
11641         }
11642         return NDR_ERR_SUCCESS;
11643 }
11644
11645 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
11646 {
11647         uint32_t _ptr_driver_name;
11648         TALLOC_CTX *_mem_save_driver_name_0;
11649         uint32_t _ptr_architecture;
11650         TALLOC_CTX *_mem_save_architecture_0;
11651         uint32_t _ptr_driver_path;
11652         TALLOC_CTX *_mem_save_driver_path_0;
11653         uint32_t _ptr_data_file;
11654         TALLOC_CTX *_mem_save_data_file_0;
11655         uint32_t _ptr_config_file;
11656         TALLOC_CTX *_mem_save_config_file_0;
11657         uint32_t _ptr_help_file;
11658         TALLOC_CTX *_mem_save_help_file_0;
11659         uint32_t _ptr_dependent_files;
11660         TALLOC_CTX *_mem_save_dependent_files_0;
11661         uint32_t _ptr_monitor_name;
11662         TALLOC_CTX *_mem_save_monitor_name_0;
11663         uint32_t _ptr_default_datatype;
11664         TALLOC_CTX *_mem_save_default_datatype_0;
11665         uint32_t _ptr_previous_names;
11666         TALLOC_CTX *_mem_save_previous_names_0;
11667         if (ndr_flags & NDR_SCALARS) {
11668                 NDR_CHECK(ndr_pull_align(ndr, 5));
11669                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11670                 {
11671                         uint32_t _flags_save_string = ndr->flags;
11672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11673                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11674                         if (_ptr_driver_name) {
11675                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11676                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11677                         } else {
11678                                 r->driver_name = NULL;
11679                         }
11680                         ndr->flags = _flags_save_string;
11681                 }
11682                 {
11683                         uint32_t _flags_save_string = ndr->flags;
11684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11685                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11686                         if (_ptr_architecture) {
11687                                 NDR_PULL_ALLOC(ndr, r->architecture);
11688                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11689                         } else {
11690                                 r->architecture = NULL;
11691                         }
11692                         ndr->flags = _flags_save_string;
11693                 }
11694                 {
11695                         uint32_t _flags_save_string = ndr->flags;
11696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11697                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11698                         if (_ptr_driver_path) {
11699                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11700                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11701                         } else {
11702                                 r->driver_path = NULL;
11703                         }
11704                         ndr->flags = _flags_save_string;
11705                 }
11706                 {
11707                         uint32_t _flags_save_string = ndr->flags;
11708                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11709                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11710                         if (_ptr_data_file) {
11711                                 NDR_PULL_ALLOC(ndr, r->data_file);
11712                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11713                         } else {
11714                                 r->data_file = NULL;
11715                         }
11716                         ndr->flags = _flags_save_string;
11717                 }
11718                 {
11719                         uint32_t _flags_save_string = ndr->flags;
11720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11721                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11722                         if (_ptr_config_file) {
11723                                 NDR_PULL_ALLOC(ndr, r->config_file);
11724                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11725                         } else {
11726                                 r->config_file = NULL;
11727                         }
11728                         ndr->flags = _flags_save_string;
11729                 }
11730                 {
11731                         uint32_t _flags_save_string = ndr->flags;
11732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11733                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11734                         if (_ptr_help_file) {
11735                                 NDR_PULL_ALLOC(ndr, r->help_file);
11736                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11737                         } else {
11738                                 r->help_file = NULL;
11739                         }
11740                         ndr->flags = _flags_save_string;
11741                 }
11742                 {
11743                         uint32_t _flags_save_string_array = ndr->flags;
11744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11745                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11746                         if (_ptr_dependent_files) {
11747                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11748                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11749                         } else {
11750                                 r->dependent_files = NULL;
11751                         }
11752                         ndr->flags = _flags_save_string_array;
11753                 }
11754                 {
11755                         uint32_t _flags_save_string = ndr->flags;
11756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11758                         if (_ptr_monitor_name) {
11759                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11761                         } else {
11762                                 r->monitor_name = NULL;
11763                         }
11764                         ndr->flags = _flags_save_string;
11765                 }
11766                 {
11767                         uint32_t _flags_save_string = ndr->flags;
11768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11769                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11770                         if (_ptr_default_datatype) {
11771                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11772                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11773                         } else {
11774                                 r->default_datatype = NULL;
11775                         }
11776                         ndr->flags = _flags_save_string;
11777                 }
11778                 {
11779                         uint32_t _flags_save_string_array = ndr->flags;
11780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11781                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11782                         if (_ptr_previous_names) {
11783                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11784                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11785                         } else {
11786                                 r->previous_names = NULL;
11787                         }
11788                         ndr->flags = _flags_save_string_array;
11789                 }
11790                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11791         }
11792         if (ndr_flags & NDR_BUFFERS) {
11793                 {
11794                         uint32_t _flags_save_string = ndr->flags;
11795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11796                         if (r->driver_name) {
11797                                 uint32_t _relative_save_offset;
11798                                 _relative_save_offset = ndr->offset;
11799                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11800                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11801                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11802                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11803                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11804                                 if (ndr->offset > ndr->relative_highest_offset) {
11805                                         ndr->relative_highest_offset = ndr->offset;
11806                                 }
11807                                 ndr->offset = _relative_save_offset;
11808                         }
11809                         ndr->flags = _flags_save_string;
11810                 }
11811                 {
11812                         uint32_t _flags_save_string = ndr->flags;
11813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11814                         if (r->architecture) {
11815                                 uint32_t _relative_save_offset;
11816                                 _relative_save_offset = ndr->offset;
11817                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11818                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11819                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11820                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11821                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11822                                 if (ndr->offset > ndr->relative_highest_offset) {
11823                                         ndr->relative_highest_offset = ndr->offset;
11824                                 }
11825                                 ndr->offset = _relative_save_offset;
11826                         }
11827                         ndr->flags = _flags_save_string;
11828                 }
11829                 {
11830                         uint32_t _flags_save_string = ndr->flags;
11831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11832                         if (r->driver_path) {
11833                                 uint32_t _relative_save_offset;
11834                                 _relative_save_offset = ndr->offset;
11835                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11836                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11837                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11838                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11839                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11840                                 if (ndr->offset > ndr->relative_highest_offset) {
11841                                         ndr->relative_highest_offset = ndr->offset;
11842                                 }
11843                                 ndr->offset = _relative_save_offset;
11844                         }
11845                         ndr->flags = _flags_save_string;
11846                 }
11847                 {
11848                         uint32_t _flags_save_string = ndr->flags;
11849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11850                         if (r->data_file) {
11851                                 uint32_t _relative_save_offset;
11852                                 _relative_save_offset = ndr->offset;
11853                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11854                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11855                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11856                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11857                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11858                                 if (ndr->offset > ndr->relative_highest_offset) {
11859                                         ndr->relative_highest_offset = ndr->offset;
11860                                 }
11861                                 ndr->offset = _relative_save_offset;
11862                         }
11863                         ndr->flags = _flags_save_string;
11864                 }
11865                 {
11866                         uint32_t _flags_save_string = ndr->flags;
11867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11868                         if (r->config_file) {
11869                                 uint32_t _relative_save_offset;
11870                                 _relative_save_offset = ndr->offset;
11871                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11872                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11873                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11874                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11875                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11876                                 if (ndr->offset > ndr->relative_highest_offset) {
11877                                         ndr->relative_highest_offset = ndr->offset;
11878                                 }
11879                                 ndr->offset = _relative_save_offset;
11880                         }
11881                         ndr->flags = _flags_save_string;
11882                 }
11883                 {
11884                         uint32_t _flags_save_string = ndr->flags;
11885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11886                         if (r->help_file) {
11887                                 uint32_t _relative_save_offset;
11888                                 _relative_save_offset = ndr->offset;
11889                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11890                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11891                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11892                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11893                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11894                                 if (ndr->offset > ndr->relative_highest_offset) {
11895                                         ndr->relative_highest_offset = ndr->offset;
11896                                 }
11897                                 ndr->offset = _relative_save_offset;
11898                         }
11899                         ndr->flags = _flags_save_string;
11900                 }
11901                 {
11902                         uint32_t _flags_save_string_array = ndr->flags;
11903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11904                         if (r->dependent_files) {
11905                                 uint32_t _relative_save_offset;
11906                                 _relative_save_offset = ndr->offset;
11907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11908                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11909                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11910                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11912                                 if (ndr->offset > ndr->relative_highest_offset) {
11913                                         ndr->relative_highest_offset = ndr->offset;
11914                                 }
11915                                 ndr->offset = _relative_save_offset;
11916                         }
11917                         ndr->flags = _flags_save_string_array;
11918                 }
11919                 {
11920                         uint32_t _flags_save_string = ndr->flags;
11921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11922                         if (r->monitor_name) {
11923                                 uint32_t _relative_save_offset;
11924                                 _relative_save_offset = ndr->offset;
11925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11926                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11927                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11930                                 if (ndr->offset > ndr->relative_highest_offset) {
11931                                         ndr->relative_highest_offset = ndr->offset;
11932                                 }
11933                                 ndr->offset = _relative_save_offset;
11934                         }
11935                         ndr->flags = _flags_save_string;
11936                 }
11937                 {
11938                         uint32_t _flags_save_string = ndr->flags;
11939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11940                         if (r->default_datatype) {
11941                                 uint32_t _relative_save_offset;
11942                                 _relative_save_offset = ndr->offset;
11943                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11944                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11945                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11946                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11947                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11948                                 if (ndr->offset > ndr->relative_highest_offset) {
11949                                         ndr->relative_highest_offset = ndr->offset;
11950                                 }
11951                                 ndr->offset = _relative_save_offset;
11952                         }
11953                         ndr->flags = _flags_save_string;
11954                 }
11955                 {
11956                         uint32_t _flags_save_string_array = ndr->flags;
11957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11958                         if (r->previous_names) {
11959                                 uint32_t _relative_save_offset;
11960                                 _relative_save_offset = ndr->offset;
11961                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11962                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11963                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11964                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11965                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11966                                 if (ndr->offset > ndr->relative_highest_offset) {
11967                                         ndr->relative_highest_offset = ndr->offset;
11968                                 }
11969                                 ndr->offset = _relative_save_offset;
11970                         }
11971                         ndr->flags = _flags_save_string_array;
11972                 }
11973         }
11974         return NDR_ERR_SUCCESS;
11975 }
11976
11977 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11978 {
11979         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11980         ndr->depth++;
11981         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11982         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11983         ndr->depth++;
11984         if (r->driver_name) {
11985                 ndr_print_string(ndr, "driver_name", r->driver_name);
11986         }
11987         ndr->depth--;
11988         ndr_print_ptr(ndr, "architecture", r->architecture);
11989         ndr->depth++;
11990         if (r->architecture) {
11991                 ndr_print_string(ndr, "architecture", r->architecture);
11992         }
11993         ndr->depth--;
11994         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11995         ndr->depth++;
11996         if (r->driver_path) {
11997                 ndr_print_string(ndr, "driver_path", r->driver_path);
11998         }
11999         ndr->depth--;
12000         ndr_print_ptr(ndr, "data_file", r->data_file);
12001         ndr->depth++;
12002         if (r->data_file) {
12003                 ndr_print_string(ndr, "data_file", r->data_file);
12004         }
12005         ndr->depth--;
12006         ndr_print_ptr(ndr, "config_file", r->config_file);
12007         ndr->depth++;
12008         if (r->config_file) {
12009                 ndr_print_string(ndr, "config_file", r->config_file);
12010         }
12011         ndr->depth--;
12012         ndr_print_ptr(ndr, "help_file", r->help_file);
12013         ndr->depth++;
12014         if (r->help_file) {
12015                 ndr_print_string(ndr, "help_file", r->help_file);
12016         }
12017         ndr->depth--;
12018         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12019         ndr->depth++;
12020         if (r->dependent_files) {
12021                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12022         }
12023         ndr->depth--;
12024         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12025         ndr->depth++;
12026         if (r->monitor_name) {
12027                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12028         }
12029         ndr->depth--;
12030         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12031         ndr->depth++;
12032         if (r->default_datatype) {
12033                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12034         }
12035         ndr->depth--;
12036         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12037         ndr->depth++;
12038         if (r->previous_names) {
12039                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12040         }
12041         ndr->depth--;
12042         ndr->depth--;
12043 }
12044
12045 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
12046 {
12047         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
12048 }
12049
12050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
12051 {
12052         if (ndr_flags & NDR_SCALARS) {
12053                 NDR_CHECK(ndr_push_align(ndr, 5));
12054                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12055                 {
12056                         uint32_t _flags_save_string = ndr->flags;
12057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12058                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12059                         ndr->flags = _flags_save_string;
12060                 }
12061                 {
12062                         uint32_t _flags_save_string = ndr->flags;
12063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12064                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12065                         ndr->flags = _flags_save_string;
12066                 }
12067                 {
12068                         uint32_t _flags_save_string = ndr->flags;
12069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12071                         ndr->flags = _flags_save_string;
12072                 }
12073                 {
12074                         uint32_t _flags_save_string = ndr->flags;
12075                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12076                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12077                         ndr->flags = _flags_save_string;
12078                 }
12079                 {
12080                         uint32_t _flags_save_string = ndr->flags;
12081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12082                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12083                         ndr->flags = _flags_save_string;
12084                 }
12085                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
12086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
12087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
12088                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12089         }
12090         if (ndr_flags & NDR_BUFFERS) {
12091                 {
12092                         uint32_t _flags_save_string = ndr->flags;
12093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12094                         if (r->driver_name) {
12095                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12096                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12097                         }
12098                         ndr->flags = _flags_save_string;
12099                 }
12100                 {
12101                         uint32_t _flags_save_string = ndr->flags;
12102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12103                         if (r->architecture) {
12104                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12105                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12106                         }
12107                         ndr->flags = _flags_save_string;
12108                 }
12109                 {
12110                         uint32_t _flags_save_string = ndr->flags;
12111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12112                         if (r->driver_path) {
12113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12114                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12115                         }
12116                         ndr->flags = _flags_save_string;
12117                 }
12118                 {
12119                         uint32_t _flags_save_string = ndr->flags;
12120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12121                         if (r->data_file) {
12122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12124                         }
12125                         ndr->flags = _flags_save_string;
12126                 }
12127                 {
12128                         uint32_t _flags_save_string = ndr->flags;
12129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12130                         if (r->config_file) {
12131                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12133                         }
12134                         ndr->flags = _flags_save_string;
12135                 }
12136         }
12137         return NDR_ERR_SUCCESS;
12138 }
12139
12140 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
12141 {
12142         uint32_t _ptr_driver_name;
12143         TALLOC_CTX *_mem_save_driver_name_0;
12144         uint32_t _ptr_architecture;
12145         TALLOC_CTX *_mem_save_architecture_0;
12146         uint32_t _ptr_driver_path;
12147         TALLOC_CTX *_mem_save_driver_path_0;
12148         uint32_t _ptr_data_file;
12149         TALLOC_CTX *_mem_save_data_file_0;
12150         uint32_t _ptr_config_file;
12151         TALLOC_CTX *_mem_save_config_file_0;
12152         if (ndr_flags & NDR_SCALARS) {
12153                 NDR_CHECK(ndr_pull_align(ndr, 5));
12154                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12155                 {
12156                         uint32_t _flags_save_string = ndr->flags;
12157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12158                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12159                         if (_ptr_driver_name) {
12160                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12161                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12162                         } else {
12163                                 r->driver_name = NULL;
12164                         }
12165                         ndr->flags = _flags_save_string;
12166                 }
12167                 {
12168                         uint32_t _flags_save_string = ndr->flags;
12169                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12170                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12171                         if (_ptr_architecture) {
12172                                 NDR_PULL_ALLOC(ndr, r->architecture);
12173                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12174                         } else {
12175                                 r->architecture = NULL;
12176                         }
12177                         ndr->flags = _flags_save_string;
12178                 }
12179                 {
12180                         uint32_t _flags_save_string = ndr->flags;
12181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12182                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12183                         if (_ptr_driver_path) {
12184                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12185                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12186                         } else {
12187                                 r->driver_path = NULL;
12188                         }
12189                         ndr->flags = _flags_save_string;
12190                 }
12191                 {
12192                         uint32_t _flags_save_string = ndr->flags;
12193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12194                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12195                         if (_ptr_data_file) {
12196                                 NDR_PULL_ALLOC(ndr, r->data_file);
12197                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12198                         } else {
12199                                 r->data_file = NULL;
12200                         }
12201                         ndr->flags = _flags_save_string;
12202                 }
12203                 {
12204                         uint32_t _flags_save_string = ndr->flags;
12205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12206                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12207                         if (_ptr_config_file) {
12208                                 NDR_PULL_ALLOC(ndr, r->config_file);
12209                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12210                         } else {
12211                                 r->config_file = NULL;
12212                         }
12213                         ndr->flags = _flags_save_string;
12214                 }
12215                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
12216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
12217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
12218                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12219         }
12220         if (ndr_flags & NDR_BUFFERS) {
12221                 {
12222                         uint32_t _flags_save_string = ndr->flags;
12223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12224                         if (r->driver_name) {
12225                                 uint32_t _relative_save_offset;
12226                                 _relative_save_offset = ndr->offset;
12227                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12228                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12229                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12230                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12231                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12232                                 if (ndr->offset > ndr->relative_highest_offset) {
12233                                         ndr->relative_highest_offset = ndr->offset;
12234                                 }
12235                                 ndr->offset = _relative_save_offset;
12236                         }
12237                         ndr->flags = _flags_save_string;
12238                 }
12239                 {
12240                         uint32_t _flags_save_string = ndr->flags;
12241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12242                         if (r->architecture) {
12243                                 uint32_t _relative_save_offset;
12244                                 _relative_save_offset = ndr->offset;
12245                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12246                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12247                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12248                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12249                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12250                                 if (ndr->offset > ndr->relative_highest_offset) {
12251                                         ndr->relative_highest_offset = ndr->offset;
12252                                 }
12253                                 ndr->offset = _relative_save_offset;
12254                         }
12255                         ndr->flags = _flags_save_string;
12256                 }
12257                 {
12258                         uint32_t _flags_save_string = ndr->flags;
12259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12260                         if (r->driver_path) {
12261                                 uint32_t _relative_save_offset;
12262                                 _relative_save_offset = ndr->offset;
12263                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12264                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12265                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12266                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12267                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12268                                 if (ndr->offset > ndr->relative_highest_offset) {
12269                                         ndr->relative_highest_offset = ndr->offset;
12270                                 }
12271                                 ndr->offset = _relative_save_offset;
12272                         }
12273                         ndr->flags = _flags_save_string;
12274                 }
12275                 {
12276                         uint32_t _flags_save_string = ndr->flags;
12277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12278                         if (r->data_file) {
12279                                 uint32_t _relative_save_offset;
12280                                 _relative_save_offset = ndr->offset;
12281                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12282                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12283                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12284                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12285                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12286                                 if (ndr->offset > ndr->relative_highest_offset) {
12287                                         ndr->relative_highest_offset = ndr->offset;
12288                                 }
12289                                 ndr->offset = _relative_save_offset;
12290                         }
12291                         ndr->flags = _flags_save_string;
12292                 }
12293                 {
12294                         uint32_t _flags_save_string = ndr->flags;
12295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12296                         if (r->config_file) {
12297                                 uint32_t _relative_save_offset;
12298                                 _relative_save_offset = ndr->offset;
12299                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12300                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12301                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12302                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12303                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12304                                 if (ndr->offset > ndr->relative_highest_offset) {
12305                                         ndr->relative_highest_offset = ndr->offset;
12306                                 }
12307                                 ndr->offset = _relative_save_offset;
12308                         }
12309                         ndr->flags = _flags_save_string;
12310                 }
12311         }
12312         return NDR_ERR_SUCCESS;
12313 }
12314
12315 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
12316 {
12317         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
12318         ndr->depth++;
12319         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12320         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12321         ndr->depth++;
12322         if (r->driver_name) {
12323                 ndr_print_string(ndr, "driver_name", r->driver_name);
12324         }
12325         ndr->depth--;
12326         ndr_print_ptr(ndr, "architecture", r->architecture);
12327         ndr->depth++;
12328         if (r->architecture) {
12329                 ndr_print_string(ndr, "architecture", r->architecture);
12330         }
12331         ndr->depth--;
12332         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12333         ndr->depth++;
12334         if (r->driver_path) {
12335                 ndr_print_string(ndr, "driver_path", r->driver_path);
12336         }
12337         ndr->depth--;
12338         ndr_print_ptr(ndr, "data_file", r->data_file);
12339         ndr->depth++;
12340         if (r->data_file) {
12341                 ndr_print_string(ndr, "data_file", r->data_file);
12342         }
12343         ndr->depth--;
12344         ndr_print_ptr(ndr, "config_file", r->config_file);
12345         ndr->depth++;
12346         if (r->config_file) {
12347                 ndr_print_string(ndr, "config_file", r->config_file);
12348         }
12349         ndr->depth--;
12350         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
12351         ndr_print_uint32(ndr, "config_version", r->config_version);
12352         ndr_print_uint32(ndr, "driver_version", r->driver_version);
12353         ndr->depth--;
12354 }
12355
12356 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
12357 {
12358         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
12359 }
12360
12361 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
12362 {
12363         if (ndr_flags & NDR_SCALARS) {
12364                 NDR_CHECK(ndr_push_align(ndr, 8));
12365                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12366                 {
12367                         uint32_t _flags_save_string = ndr->flags;
12368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12369                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12370                         ndr->flags = _flags_save_string;
12371                 }
12372                 {
12373                         uint32_t _flags_save_string = ndr->flags;
12374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12375                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12376                         ndr->flags = _flags_save_string;
12377                 }
12378                 {
12379                         uint32_t _flags_save_string = ndr->flags;
12380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12381                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12382                         ndr->flags = _flags_save_string;
12383                 }
12384                 {
12385                         uint32_t _flags_save_string = ndr->flags;
12386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12387                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12388                         ndr->flags = _flags_save_string;
12389                 }
12390                 {
12391                         uint32_t _flags_save_string = ndr->flags;
12392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12393                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12394                         ndr->flags = _flags_save_string;
12395                 }
12396                 {
12397                         uint32_t _flags_save_string = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12400                         ndr->flags = _flags_save_string;
12401                 }
12402                 {
12403                         uint32_t _flags_save_string_array = ndr->flags;
12404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12405                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12406                         ndr->flags = _flags_save_string_array;
12407                 }
12408                 {
12409                         uint32_t _flags_save_string = ndr->flags;
12410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12411                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12412                         ndr->flags = _flags_save_string;
12413                 }
12414                 {
12415                         uint32_t _flags_save_string = ndr->flags;
12416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12417                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12418                         ndr->flags = _flags_save_string;
12419                 }
12420                 {
12421                         uint32_t _flags_save_string_array = ndr->flags;
12422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12423                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12424                         ndr->flags = _flags_save_string_array;
12425                 }
12426                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12427                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12428                 {
12429                         uint32_t _flags_save_string = ndr->flags;
12430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12431                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12432                         ndr->flags = _flags_save_string;
12433                 }
12434                 {
12435                         uint32_t _flags_save_string = ndr->flags;
12436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12438                         ndr->flags = _flags_save_string;
12439                 }
12440                 {
12441                         uint32_t _flags_save_string = ndr->flags;
12442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12443                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12444                         ndr->flags = _flags_save_string;
12445                 }
12446                 {
12447                         uint32_t _flags_save_string = ndr->flags;
12448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12449                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12450                         ndr->flags = _flags_save_string;
12451                 }
12452                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12453         }
12454         if (ndr_flags & NDR_BUFFERS) {
12455                 {
12456                         uint32_t _flags_save_string = ndr->flags;
12457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12458                         if (r->driver_name) {
12459                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12460                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12461                         }
12462                         ndr->flags = _flags_save_string;
12463                 }
12464                 {
12465                         uint32_t _flags_save_string = ndr->flags;
12466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12467                         if (r->architecture) {
12468                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12469                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12470                         }
12471                         ndr->flags = _flags_save_string;
12472                 }
12473                 {
12474                         uint32_t _flags_save_string = ndr->flags;
12475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12476                         if (r->driver_path) {
12477                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12478                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12479                         }
12480                         ndr->flags = _flags_save_string;
12481                 }
12482                 {
12483                         uint32_t _flags_save_string = ndr->flags;
12484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12485                         if (r->data_file) {
12486                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12487                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12488                         }
12489                         ndr->flags = _flags_save_string;
12490                 }
12491                 {
12492                         uint32_t _flags_save_string = ndr->flags;
12493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12494                         if (r->config_file) {
12495                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12496                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12497                         }
12498                         ndr->flags = _flags_save_string;
12499                 }
12500                 {
12501                         uint32_t _flags_save_string = ndr->flags;
12502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12503                         if (r->help_file) {
12504                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12505                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12506                         }
12507                         ndr->flags = _flags_save_string;
12508                 }
12509                 {
12510                         uint32_t _flags_save_string_array = ndr->flags;
12511                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12512                         if (r->dependent_files) {
12513                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12514                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12515                         }
12516                         ndr->flags = _flags_save_string_array;
12517                 }
12518                 {
12519                         uint32_t _flags_save_string = ndr->flags;
12520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12521                         if (r->monitor_name) {
12522                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12523                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12524                         }
12525                         ndr->flags = _flags_save_string;
12526                 }
12527                 {
12528                         uint32_t _flags_save_string = ndr->flags;
12529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12530                         if (r->default_datatype) {
12531                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12532                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12533                         }
12534                         ndr->flags = _flags_save_string;
12535                 }
12536                 {
12537                         uint32_t _flags_save_string_array = ndr->flags;
12538                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12539                         if (r->previous_names) {
12540                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12541                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12542                         }
12543                         ndr->flags = _flags_save_string_array;
12544                 }
12545                 {
12546                         uint32_t _flags_save_string = ndr->flags;
12547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12548                         if (r->manufacturer_name) {
12549                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12550                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12551                         }
12552                         ndr->flags = _flags_save_string;
12553                 }
12554                 {
12555                         uint32_t _flags_save_string = ndr->flags;
12556                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12557                         if (r->manufacturer_url) {
12558                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12559                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12560                         }
12561                         ndr->flags = _flags_save_string;
12562                 }
12563                 {
12564                         uint32_t _flags_save_string = ndr->flags;
12565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12566                         if (r->hardware_id) {
12567                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12568                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12569                         }
12570                         ndr->flags = _flags_save_string;
12571                 }
12572                 {
12573                         uint32_t _flags_save_string = ndr->flags;
12574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12575                         if (r->provider) {
12576                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12577                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12578                         }
12579                         ndr->flags = _flags_save_string;
12580                 }
12581         }
12582         return NDR_ERR_SUCCESS;
12583 }
12584
12585 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
12586 {
12587         uint32_t _ptr_driver_name;
12588         TALLOC_CTX *_mem_save_driver_name_0;
12589         uint32_t _ptr_architecture;
12590         TALLOC_CTX *_mem_save_architecture_0;
12591         uint32_t _ptr_driver_path;
12592         TALLOC_CTX *_mem_save_driver_path_0;
12593         uint32_t _ptr_data_file;
12594         TALLOC_CTX *_mem_save_data_file_0;
12595         uint32_t _ptr_config_file;
12596         TALLOC_CTX *_mem_save_config_file_0;
12597         uint32_t _ptr_help_file;
12598         TALLOC_CTX *_mem_save_help_file_0;
12599         uint32_t _ptr_dependent_files;
12600         TALLOC_CTX *_mem_save_dependent_files_0;
12601         uint32_t _ptr_monitor_name;
12602         TALLOC_CTX *_mem_save_monitor_name_0;
12603         uint32_t _ptr_default_datatype;
12604         TALLOC_CTX *_mem_save_default_datatype_0;
12605         uint32_t _ptr_previous_names;
12606         TALLOC_CTX *_mem_save_previous_names_0;
12607         uint32_t _ptr_manufacturer_name;
12608         TALLOC_CTX *_mem_save_manufacturer_name_0;
12609         uint32_t _ptr_manufacturer_url;
12610         TALLOC_CTX *_mem_save_manufacturer_url_0;
12611         uint32_t _ptr_hardware_id;
12612         TALLOC_CTX *_mem_save_hardware_id_0;
12613         uint32_t _ptr_provider;
12614         TALLOC_CTX *_mem_save_provider_0;
12615         if (ndr_flags & NDR_SCALARS) {
12616                 NDR_CHECK(ndr_pull_align(ndr, 8));
12617                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12618                 {
12619                         uint32_t _flags_save_string = ndr->flags;
12620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12621                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12622                         if (_ptr_driver_name) {
12623                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12624                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12625                         } else {
12626                                 r->driver_name = NULL;
12627                         }
12628                         ndr->flags = _flags_save_string;
12629                 }
12630                 {
12631                         uint32_t _flags_save_string = ndr->flags;
12632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12633                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12634                         if (_ptr_architecture) {
12635                                 NDR_PULL_ALLOC(ndr, r->architecture);
12636                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12637                         } else {
12638                                 r->architecture = NULL;
12639                         }
12640                         ndr->flags = _flags_save_string;
12641                 }
12642                 {
12643                         uint32_t _flags_save_string = ndr->flags;
12644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12645                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12646                         if (_ptr_driver_path) {
12647                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12648                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12649                         } else {
12650                                 r->driver_path = NULL;
12651                         }
12652                         ndr->flags = _flags_save_string;
12653                 }
12654                 {
12655                         uint32_t _flags_save_string = ndr->flags;
12656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12657                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12658                         if (_ptr_data_file) {
12659                                 NDR_PULL_ALLOC(ndr, r->data_file);
12660                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12661                         } else {
12662                                 r->data_file = NULL;
12663                         }
12664                         ndr->flags = _flags_save_string;
12665                 }
12666                 {
12667                         uint32_t _flags_save_string = ndr->flags;
12668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12669                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12670                         if (_ptr_config_file) {
12671                                 NDR_PULL_ALLOC(ndr, r->config_file);
12672                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12673                         } else {
12674                                 r->config_file = NULL;
12675                         }
12676                         ndr->flags = _flags_save_string;
12677                 }
12678                 {
12679                         uint32_t _flags_save_string = ndr->flags;
12680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12681                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12682                         if (_ptr_help_file) {
12683                                 NDR_PULL_ALLOC(ndr, r->help_file);
12684                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12685                         } else {
12686                                 r->help_file = NULL;
12687                         }
12688                         ndr->flags = _flags_save_string;
12689                 }
12690                 {
12691                         uint32_t _flags_save_string_array = ndr->flags;
12692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12694                         if (_ptr_dependent_files) {
12695                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12697                         } else {
12698                                 r->dependent_files = NULL;
12699                         }
12700                         ndr->flags = _flags_save_string_array;
12701                 }
12702                 {
12703                         uint32_t _flags_save_string = ndr->flags;
12704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12706                         if (_ptr_monitor_name) {
12707                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12709                         } else {
12710                                 r->monitor_name = NULL;
12711                         }
12712                         ndr->flags = _flags_save_string;
12713                 }
12714                 {
12715                         uint32_t _flags_save_string = ndr->flags;
12716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12718                         if (_ptr_default_datatype) {
12719                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12721                         } else {
12722                                 r->default_datatype = NULL;
12723                         }
12724                         ndr->flags = _flags_save_string;
12725                 }
12726                 {
12727                         uint32_t _flags_save_string_array = ndr->flags;
12728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12730                         if (_ptr_previous_names) {
12731                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12733                         } else {
12734                                 r->previous_names = NULL;
12735                         }
12736                         ndr->flags = _flags_save_string_array;
12737                 }
12738                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12739                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12740                 {
12741                         uint32_t _flags_save_string = ndr->flags;
12742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12744                         if (_ptr_manufacturer_name) {
12745                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12747                         } else {
12748                                 r->manufacturer_name = NULL;
12749                         }
12750                         ndr->flags = _flags_save_string;
12751                 }
12752                 {
12753                         uint32_t _flags_save_string = ndr->flags;
12754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12756                         if (_ptr_manufacturer_url) {
12757                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12759                         } else {
12760                                 r->manufacturer_url = NULL;
12761                         }
12762                         ndr->flags = _flags_save_string;
12763                 }
12764                 {
12765                         uint32_t _flags_save_string = ndr->flags;
12766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12768                         if (_ptr_hardware_id) {
12769                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12771                         } else {
12772                                 r->hardware_id = NULL;
12773                         }
12774                         ndr->flags = _flags_save_string;
12775                 }
12776                 {
12777                         uint32_t _flags_save_string = ndr->flags;
12778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12780                         if (_ptr_provider) {
12781                                 NDR_PULL_ALLOC(ndr, r->provider);
12782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12783                         } else {
12784                                 r->provider = NULL;
12785                         }
12786                         ndr->flags = _flags_save_string;
12787                 }
12788                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12789         }
12790         if (ndr_flags & NDR_BUFFERS) {
12791                 {
12792                         uint32_t _flags_save_string = ndr->flags;
12793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12794                         if (r->driver_name) {
12795                                 uint32_t _relative_save_offset;
12796                                 _relative_save_offset = ndr->offset;
12797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12798                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12799                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12802                                 if (ndr->offset > ndr->relative_highest_offset) {
12803                                         ndr->relative_highest_offset = ndr->offset;
12804                                 }
12805                                 ndr->offset = _relative_save_offset;
12806                         }
12807                         ndr->flags = _flags_save_string;
12808                 }
12809                 {
12810                         uint32_t _flags_save_string = ndr->flags;
12811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12812                         if (r->architecture) {
12813                                 uint32_t _relative_save_offset;
12814                                 _relative_save_offset = ndr->offset;
12815                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12816                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12817                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12818                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12819                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12820                                 if (ndr->offset > ndr->relative_highest_offset) {
12821                                         ndr->relative_highest_offset = ndr->offset;
12822                                 }
12823                                 ndr->offset = _relative_save_offset;
12824                         }
12825                         ndr->flags = _flags_save_string;
12826                 }
12827                 {
12828                         uint32_t _flags_save_string = ndr->flags;
12829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12830                         if (r->driver_path) {
12831                                 uint32_t _relative_save_offset;
12832                                 _relative_save_offset = ndr->offset;
12833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12834                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12835                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12838                                 if (ndr->offset > ndr->relative_highest_offset) {
12839                                         ndr->relative_highest_offset = ndr->offset;
12840                                 }
12841                                 ndr->offset = _relative_save_offset;
12842                         }
12843                         ndr->flags = _flags_save_string;
12844                 }
12845                 {
12846                         uint32_t _flags_save_string = ndr->flags;
12847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12848                         if (r->data_file) {
12849                                 uint32_t _relative_save_offset;
12850                                 _relative_save_offset = ndr->offset;
12851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12852                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12853                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12856                                 if (ndr->offset > ndr->relative_highest_offset) {
12857                                         ndr->relative_highest_offset = ndr->offset;
12858                                 }
12859                                 ndr->offset = _relative_save_offset;
12860                         }
12861                         ndr->flags = _flags_save_string;
12862                 }
12863                 {
12864                         uint32_t _flags_save_string = ndr->flags;
12865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12866                         if (r->config_file) {
12867                                 uint32_t _relative_save_offset;
12868                                 _relative_save_offset = ndr->offset;
12869                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12870                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12871                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12872                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12873                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12874                                 if (ndr->offset > ndr->relative_highest_offset) {
12875                                         ndr->relative_highest_offset = ndr->offset;
12876                                 }
12877                                 ndr->offset = _relative_save_offset;
12878                         }
12879                         ndr->flags = _flags_save_string;
12880                 }
12881                 {
12882                         uint32_t _flags_save_string = ndr->flags;
12883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12884                         if (r->help_file) {
12885                                 uint32_t _relative_save_offset;
12886                                 _relative_save_offset = ndr->offset;
12887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12888                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12889                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12892                                 if (ndr->offset > ndr->relative_highest_offset) {
12893                                         ndr->relative_highest_offset = ndr->offset;
12894                                 }
12895                                 ndr->offset = _relative_save_offset;
12896                         }
12897                         ndr->flags = _flags_save_string;
12898                 }
12899                 {
12900                         uint32_t _flags_save_string_array = ndr->flags;
12901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12902                         if (r->dependent_files) {
12903                                 uint32_t _relative_save_offset;
12904                                 _relative_save_offset = ndr->offset;
12905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12906                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12907                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12908                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12910                                 if (ndr->offset > ndr->relative_highest_offset) {
12911                                         ndr->relative_highest_offset = ndr->offset;
12912                                 }
12913                                 ndr->offset = _relative_save_offset;
12914                         }
12915                         ndr->flags = _flags_save_string_array;
12916                 }
12917                 {
12918                         uint32_t _flags_save_string = ndr->flags;
12919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12920                         if (r->monitor_name) {
12921                                 uint32_t _relative_save_offset;
12922                                 _relative_save_offset = ndr->offset;
12923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12924                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12925                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12928                                 if (ndr->offset > ndr->relative_highest_offset) {
12929                                         ndr->relative_highest_offset = ndr->offset;
12930                                 }
12931                                 ndr->offset = _relative_save_offset;
12932                         }
12933                         ndr->flags = _flags_save_string;
12934                 }
12935                 {
12936                         uint32_t _flags_save_string = ndr->flags;
12937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12938                         if (r->default_datatype) {
12939                                 uint32_t _relative_save_offset;
12940                                 _relative_save_offset = ndr->offset;
12941                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12942                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12943                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12944                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12945                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12946                                 if (ndr->offset > ndr->relative_highest_offset) {
12947                                         ndr->relative_highest_offset = ndr->offset;
12948                                 }
12949                                 ndr->offset = _relative_save_offset;
12950                         }
12951                         ndr->flags = _flags_save_string;
12952                 }
12953                 {
12954                         uint32_t _flags_save_string_array = ndr->flags;
12955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12956                         if (r->previous_names) {
12957                                 uint32_t _relative_save_offset;
12958                                 _relative_save_offset = ndr->offset;
12959                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12960                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12961                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12962                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12963                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12964                                 if (ndr->offset > ndr->relative_highest_offset) {
12965                                         ndr->relative_highest_offset = ndr->offset;
12966                                 }
12967                                 ndr->offset = _relative_save_offset;
12968                         }
12969                         ndr->flags = _flags_save_string_array;
12970                 }
12971                 {
12972                         uint32_t _flags_save_string = ndr->flags;
12973                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12974                         if (r->manufacturer_name) {
12975                                 uint32_t _relative_save_offset;
12976                                 _relative_save_offset = ndr->offset;
12977                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12978                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12979                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12980                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12981                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12982                                 if (ndr->offset > ndr->relative_highest_offset) {
12983                                         ndr->relative_highest_offset = ndr->offset;
12984                                 }
12985                                 ndr->offset = _relative_save_offset;
12986                         }
12987                         ndr->flags = _flags_save_string;
12988                 }
12989                 {
12990                         uint32_t _flags_save_string = ndr->flags;
12991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12992                         if (r->manufacturer_url) {
12993                                 uint32_t _relative_save_offset;
12994                                 _relative_save_offset = ndr->offset;
12995                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12996                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12997                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12998                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12999                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13000                                 if (ndr->offset > ndr->relative_highest_offset) {
13001                                         ndr->relative_highest_offset = ndr->offset;
13002                                 }
13003                                 ndr->offset = _relative_save_offset;
13004                         }
13005                         ndr->flags = _flags_save_string;
13006                 }
13007                 {
13008                         uint32_t _flags_save_string = ndr->flags;
13009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13010                         if (r->hardware_id) {
13011                                 uint32_t _relative_save_offset;
13012                                 _relative_save_offset = ndr->offset;
13013                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13014                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13015                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13016                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13017                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13018                                 if (ndr->offset > ndr->relative_highest_offset) {
13019                                         ndr->relative_highest_offset = ndr->offset;
13020                                 }
13021                                 ndr->offset = _relative_save_offset;
13022                         }
13023                         ndr->flags = _flags_save_string;
13024                 }
13025                 {
13026                         uint32_t _flags_save_string = ndr->flags;
13027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13028                         if (r->provider) {
13029                                 uint32_t _relative_save_offset;
13030                                 _relative_save_offset = ndr->offset;
13031                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13032                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13033                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13034                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13035                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13036                                 if (ndr->offset > ndr->relative_highest_offset) {
13037                                         ndr->relative_highest_offset = ndr->offset;
13038                                 }
13039                                 ndr->offset = _relative_save_offset;
13040                         }
13041                         ndr->flags = _flags_save_string;
13042                 }
13043         }
13044         return NDR_ERR_SUCCESS;
13045 }
13046
13047 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
13048 {
13049         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
13050         ndr->depth++;
13051         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13052         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13053         ndr->depth++;
13054         if (r->driver_name) {
13055                 ndr_print_string(ndr, "driver_name", r->driver_name);
13056         }
13057         ndr->depth--;
13058         ndr_print_ptr(ndr, "architecture", r->architecture);
13059         ndr->depth++;
13060         if (r->architecture) {
13061                 ndr_print_string(ndr, "architecture", r->architecture);
13062         }
13063         ndr->depth--;
13064         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13065         ndr->depth++;
13066         if (r->driver_path) {
13067                 ndr_print_string(ndr, "driver_path", r->driver_path);
13068         }
13069         ndr->depth--;
13070         ndr_print_ptr(ndr, "data_file", r->data_file);
13071         ndr->depth++;
13072         if (r->data_file) {
13073                 ndr_print_string(ndr, "data_file", r->data_file);
13074         }
13075         ndr->depth--;
13076         ndr_print_ptr(ndr, "config_file", r->config_file);
13077         ndr->depth++;
13078         if (r->config_file) {
13079                 ndr_print_string(ndr, "config_file", r->config_file);
13080         }
13081         ndr->depth--;
13082         ndr_print_ptr(ndr, "help_file", r->help_file);
13083         ndr->depth++;
13084         if (r->help_file) {
13085                 ndr_print_string(ndr, "help_file", r->help_file);
13086         }
13087         ndr->depth--;
13088         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13089         ndr->depth++;
13090         if (r->dependent_files) {
13091                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13092         }
13093         ndr->depth--;
13094         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13095         ndr->depth++;
13096         if (r->monitor_name) {
13097                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13098         }
13099         ndr->depth--;
13100         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13101         ndr->depth++;
13102         if (r->default_datatype) {
13103                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13104         }
13105         ndr->depth--;
13106         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13107         ndr->depth++;
13108         if (r->previous_names) {
13109                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13110         }
13111         ndr->depth--;
13112         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13113         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13114         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13115         ndr->depth++;
13116         if (r->manufacturer_name) {
13117                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13118         }
13119         ndr->depth--;
13120         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13121         ndr->depth++;
13122         if (r->manufacturer_url) {
13123                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13124         }
13125         ndr->depth--;
13126         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13127         ndr->depth++;
13128         if (r->hardware_id) {
13129                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13130         }
13131         ndr->depth--;
13132         ndr_print_ptr(ndr, "provider", r->provider);
13133         ndr->depth++;
13134         if (r->provider) {
13135                 ndr_print_string(ndr, "provider", r->provider);
13136         }
13137         ndr->depth--;
13138         ndr->depth--;
13139 }
13140
13141 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
13142 {
13143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
13144 }
13145
13146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo7 *r)
13147 {
13148         if (ndr_flags & NDR_SCALARS) {
13149                 NDR_CHECK(ndr_push_align(ndr, 5));
13150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
13151                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13152                 {
13153                         uint32_t _flags_save_string = ndr->flags;
13154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13155                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13156                         ndr->flags = _flags_save_string;
13157                 }
13158                 {
13159                         uint32_t _flags_save_string = ndr->flags;
13160                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13161                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_name));
13162                         ndr->flags = _flags_save_string;
13163                 }
13164                 {
13165                         uint32_t _flags_save_string = ndr->flags;
13166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13167                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->install_source_root));
13168                         ndr->flags = _flags_save_string;
13169                 }
13170                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13171         }
13172         if (ndr_flags & NDR_BUFFERS) {
13173                 {
13174                         uint32_t _flags_save_string = ndr->flags;
13175                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13176                         if (r->driver_name) {
13177                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13178                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13179                         }
13180                         ndr->flags = _flags_save_string;
13181                 }
13182                 {
13183                         uint32_t _flags_save_string = ndr->flags;
13184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13185                         if (r->inf_name) {
13186                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_name));
13187                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_name));
13188                         }
13189                         ndr->flags = _flags_save_string;
13190                 }
13191                 {
13192                         uint32_t _flags_save_string = ndr->flags;
13193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13194                         if (r->install_source_root) {
13195                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->install_source_root));
13196                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->install_source_root));
13197                         }
13198                         ndr->flags = _flags_save_string;
13199                 }
13200         }
13201         return NDR_ERR_SUCCESS;
13202 }
13203
13204 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo7 *r)
13205 {
13206         uint32_t _ptr_driver_name;
13207         TALLOC_CTX *_mem_save_driver_name_0;
13208         uint32_t _ptr_inf_name;
13209         TALLOC_CTX *_mem_save_inf_name_0;
13210         uint32_t _ptr_install_source_root;
13211         TALLOC_CTX *_mem_save_install_source_root_0;
13212         if (ndr_flags & NDR_SCALARS) {
13213                 NDR_CHECK(ndr_pull_align(ndr, 5));
13214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
13215                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13216                 {
13217                         uint32_t _flags_save_string = ndr->flags;
13218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13220                         if (_ptr_driver_name) {
13221                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13223                         } else {
13224                                 r->driver_name = NULL;
13225                         }
13226                         ndr->flags = _flags_save_string;
13227                 }
13228                 {
13229                         uint32_t _flags_save_string = ndr->flags;
13230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13231                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_name));
13232                         if (_ptr_inf_name) {
13233                                 NDR_PULL_ALLOC(ndr, r->inf_name);
13234                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_name, _ptr_inf_name));
13235                         } else {
13236                                 r->inf_name = NULL;
13237                         }
13238                         ndr->flags = _flags_save_string;
13239                 }
13240                 {
13241                         uint32_t _flags_save_string = ndr->flags;
13242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13243                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_install_source_root));
13244                         if (_ptr_install_source_root) {
13245                                 NDR_PULL_ALLOC(ndr, r->install_source_root);
13246                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->install_source_root, _ptr_install_source_root));
13247                         } else {
13248                                 r->install_source_root = NULL;
13249                         }
13250                         ndr->flags = _flags_save_string;
13251                 }
13252                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13253         }
13254         if (ndr_flags & NDR_BUFFERS) {
13255                 {
13256                         uint32_t _flags_save_string = ndr->flags;
13257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13258                         if (r->driver_name) {
13259                                 uint32_t _relative_save_offset;
13260                                 _relative_save_offset = ndr->offset;
13261                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13262                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13263                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13264                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13265                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13266                                 if (ndr->offset > ndr->relative_highest_offset) {
13267                                         ndr->relative_highest_offset = ndr->offset;
13268                                 }
13269                                 ndr->offset = _relative_save_offset;
13270                         }
13271                         ndr->flags = _flags_save_string;
13272                 }
13273                 {
13274                         uint32_t _flags_save_string = ndr->flags;
13275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13276                         if (r->inf_name) {
13277                                 uint32_t _relative_save_offset;
13278                                 _relative_save_offset = ndr->offset;
13279                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_name));
13280                                 _mem_save_inf_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13281                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_name, 0);
13282                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_name));
13283                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_name_0, 0);
13284                                 if (ndr->offset > ndr->relative_highest_offset) {
13285                                         ndr->relative_highest_offset = ndr->offset;
13286                                 }
13287                                 ndr->offset = _relative_save_offset;
13288                         }
13289                         ndr->flags = _flags_save_string;
13290                 }
13291                 {
13292                         uint32_t _flags_save_string = ndr->flags;
13293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13294                         if (r->install_source_root) {
13295                                 uint32_t _relative_save_offset;
13296                                 _relative_save_offset = ndr->offset;
13297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->install_source_root));
13298                                 _mem_save_install_source_root_0 = NDR_PULL_GET_MEM_CTX(ndr);
13299                                 NDR_PULL_SET_MEM_CTX(ndr, r->install_source_root, 0);
13300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->install_source_root));
13301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_install_source_root_0, 0);
13302                                 if (ndr->offset > ndr->relative_highest_offset) {
13303                                         ndr->relative_highest_offset = ndr->offset;
13304                                 }
13305                                 ndr->offset = _relative_save_offset;
13306                         }
13307                         ndr->flags = _flags_save_string;
13308                 }
13309         }
13310         return NDR_ERR_SUCCESS;
13311 }
13312
13313 _PUBLIC_ void ndr_print_spoolss_DriverInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo7 *r)
13314 {
13315         ndr_print_struct(ndr, name, "spoolss_DriverInfo7");
13316         ndr->depth++;
13317         ndr_print_uint32(ndr, "size", r->size);
13318         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13319         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13320         ndr->depth++;
13321         if (r->driver_name) {
13322                 ndr_print_string(ndr, "driver_name", r->driver_name);
13323         }
13324         ndr->depth--;
13325         ndr_print_ptr(ndr, "inf_name", r->inf_name);
13326         ndr->depth++;
13327         if (r->inf_name) {
13328                 ndr_print_string(ndr, "inf_name", r->inf_name);
13329         }
13330         ndr->depth--;
13331         ndr_print_ptr(ndr, "install_source_root", r->install_source_root);
13332         ndr->depth++;
13333         if (r->install_source_root) {
13334                 ndr_print_string(ndr, "install_source_root", r->install_source_root);
13335         }
13336         ndr->depth--;
13337         ndr->depth--;
13338 }
13339
13340 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo7(const struct spoolss_DriverInfo7 *r, struct smb_iconv_convenience *ic, int flags)
13341 {
13342         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo7, ic);
13343 }
13344
13345 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
13346 {
13347         if (ndr_flags & NDR_SCALARS) {
13348                 NDR_CHECK(ndr_push_align(ndr, 8));
13349                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
13350                 {
13351                         uint32_t _flags_save_string = ndr->flags;
13352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
13354                         ndr->flags = _flags_save_string;
13355                 }
13356                 {
13357                         uint32_t _flags_save_string = ndr->flags;
13358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13359                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
13360                         ndr->flags = _flags_save_string;
13361                 }
13362                 {
13363                         uint32_t _flags_save_string = ndr->flags;
13364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13365                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
13366                         ndr->flags = _flags_save_string;
13367                 }
13368                 {
13369                         uint32_t _flags_save_string = ndr->flags;
13370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13371                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
13372                         ndr->flags = _flags_save_string;
13373                 }
13374                 {
13375                         uint32_t _flags_save_string = ndr->flags;
13376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
13378                         ndr->flags = _flags_save_string;
13379                 }
13380                 {
13381                         uint32_t _flags_save_string = ndr->flags;
13382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13383                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
13384                         ndr->flags = _flags_save_string;
13385                 }
13386                 {
13387                         uint32_t _flags_save_string_array = ndr->flags;
13388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13389                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
13390                         ndr->flags = _flags_save_string_array;
13391                 }
13392                 {
13393                         uint32_t _flags_save_string = ndr->flags;
13394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13395                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
13396                         ndr->flags = _flags_save_string;
13397                 }
13398                 {
13399                         uint32_t _flags_save_string = ndr->flags;
13400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13401                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
13402                         ndr->flags = _flags_save_string;
13403                 }
13404                 {
13405                         uint32_t _flags_save_string_array = ndr->flags;
13406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13407                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
13408                         ndr->flags = _flags_save_string_array;
13409                 }
13410                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
13411                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
13412                 {
13413                         uint32_t _flags_save_string = ndr->flags;
13414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13415                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
13416                         ndr->flags = _flags_save_string;
13417                 }
13418                 {
13419                         uint32_t _flags_save_string = ndr->flags;
13420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13421                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
13422                         ndr->flags = _flags_save_string;
13423                 }
13424                 {
13425                         uint32_t _flags_save_string = ndr->flags;
13426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13427                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
13428                         ndr->flags = _flags_save_string;
13429                 }
13430                 {
13431                         uint32_t _flags_save_string = ndr->flags;
13432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13433                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
13434                         ndr->flags = _flags_save_string;
13435                 }
13436                 {
13437                         uint32_t _flags_save_string = ndr->flags;
13438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
13440                         ndr->flags = _flags_save_string;
13441                 }
13442                 {
13443                         uint32_t _flags_save_string = ndr->flags;
13444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
13446                         ndr->flags = _flags_save_string;
13447                 }
13448                 {
13449                         uint32_t _flags_save_string_array = ndr->flags;
13450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13451                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
13452                         ndr->flags = _flags_save_string_array;
13453                 }
13454                 {
13455                         uint32_t _flags_save_string = ndr->flags;
13456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13457                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
13458                         ndr->flags = _flags_save_string;
13459                 }
13460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
13461                 {
13462                         uint32_t _flags_save_string_array = ndr->flags;
13463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13464                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
13465                         ndr->flags = _flags_save_string_array;
13466                 }
13467                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
13468                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
13469                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
13470         }
13471         if (ndr_flags & NDR_BUFFERS) {
13472                 {
13473                         uint32_t _flags_save_string = ndr->flags;
13474                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13475                         if (r->driver_name) {
13476                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
13477                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
13478                         }
13479                         ndr->flags = _flags_save_string;
13480                 }
13481                 {
13482                         uint32_t _flags_save_string = ndr->flags;
13483                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13484                         if (r->architecture) {
13485                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
13486                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
13487                         }
13488                         ndr->flags = _flags_save_string;
13489                 }
13490                 {
13491                         uint32_t _flags_save_string = ndr->flags;
13492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13493                         if (r->driver_path) {
13494                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
13495                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
13496                         }
13497                         ndr->flags = _flags_save_string;
13498                 }
13499                 {
13500                         uint32_t _flags_save_string = ndr->flags;
13501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13502                         if (r->data_file) {
13503                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
13504                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
13505                         }
13506                         ndr->flags = _flags_save_string;
13507                 }
13508                 {
13509                         uint32_t _flags_save_string = ndr->flags;
13510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13511                         if (r->config_file) {
13512                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
13513                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
13514                         }
13515                         ndr->flags = _flags_save_string;
13516                 }
13517                 {
13518                         uint32_t _flags_save_string = ndr->flags;
13519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13520                         if (r->help_file) {
13521                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
13522                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
13523                         }
13524                         ndr->flags = _flags_save_string;
13525                 }
13526                 {
13527                         uint32_t _flags_save_string_array = ndr->flags;
13528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13529                         if (r->dependent_files) {
13530                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
13531                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
13532                         }
13533                         ndr->flags = _flags_save_string_array;
13534                 }
13535                 {
13536                         uint32_t _flags_save_string = ndr->flags;
13537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13538                         if (r->monitor_name) {
13539                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
13540                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
13541                         }
13542                         ndr->flags = _flags_save_string;
13543                 }
13544                 {
13545                         uint32_t _flags_save_string = ndr->flags;
13546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13547                         if (r->default_datatype) {
13548                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
13549                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
13550                         }
13551                         ndr->flags = _flags_save_string;
13552                 }
13553                 {
13554                         uint32_t _flags_save_string_array = ndr->flags;
13555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13556                         if (r->previous_names) {
13557                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
13558                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
13559                         }
13560                         ndr->flags = _flags_save_string_array;
13561                 }
13562                 {
13563                         uint32_t _flags_save_string = ndr->flags;
13564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13565                         if (r->manufacturer_name) {
13566                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
13567                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
13568                         }
13569                         ndr->flags = _flags_save_string;
13570                 }
13571                 {
13572                         uint32_t _flags_save_string = ndr->flags;
13573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13574                         if (r->manufacturer_url) {
13575                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
13576                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
13577                         }
13578                         ndr->flags = _flags_save_string;
13579                 }
13580                 {
13581                         uint32_t _flags_save_string = ndr->flags;
13582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13583                         if (r->hardware_id) {
13584                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
13585                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
13586                         }
13587                         ndr->flags = _flags_save_string;
13588                 }
13589                 {
13590                         uint32_t _flags_save_string = ndr->flags;
13591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13592                         if (r->provider) {
13593                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
13594                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
13595                         }
13596                         ndr->flags = _flags_save_string;
13597                 }
13598                 {
13599                         uint32_t _flags_save_string = ndr->flags;
13600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13601                         if (r->print_processor) {
13602                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
13603                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
13604                         }
13605                         ndr->flags = _flags_save_string;
13606                 }
13607                 {
13608                         uint32_t _flags_save_string = ndr->flags;
13609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13610                         if (r->vendor_setup) {
13611                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
13612                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
13613                         }
13614                         ndr->flags = _flags_save_string;
13615                 }
13616                 {
13617                         uint32_t _flags_save_string_array = ndr->flags;
13618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13619                         if (r->color_profiles) {
13620                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
13621                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
13622                         }
13623                         ndr->flags = _flags_save_string_array;
13624                 }
13625                 {
13626                         uint32_t _flags_save_string = ndr->flags;
13627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13628                         if (r->inf_path) {
13629                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
13630                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
13631                         }
13632                         ndr->flags = _flags_save_string;
13633                 }
13634                 {
13635                         uint32_t _flags_save_string_array = ndr->flags;
13636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13637                         if (r->core_driver_dependencies) {
13638                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
13639                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
13640                         }
13641                         ndr->flags = _flags_save_string_array;
13642                 }
13643         }
13644         return NDR_ERR_SUCCESS;
13645 }
13646
13647 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
13648 {
13649         uint32_t _ptr_driver_name;
13650         TALLOC_CTX *_mem_save_driver_name_0;
13651         uint32_t _ptr_architecture;
13652         TALLOC_CTX *_mem_save_architecture_0;
13653         uint32_t _ptr_driver_path;
13654         TALLOC_CTX *_mem_save_driver_path_0;
13655         uint32_t _ptr_data_file;
13656         TALLOC_CTX *_mem_save_data_file_0;
13657         uint32_t _ptr_config_file;
13658         TALLOC_CTX *_mem_save_config_file_0;
13659         uint32_t _ptr_help_file;
13660         TALLOC_CTX *_mem_save_help_file_0;
13661         uint32_t _ptr_dependent_files;
13662         TALLOC_CTX *_mem_save_dependent_files_0;
13663         uint32_t _ptr_monitor_name;
13664         TALLOC_CTX *_mem_save_monitor_name_0;
13665         uint32_t _ptr_default_datatype;
13666         TALLOC_CTX *_mem_save_default_datatype_0;
13667         uint32_t _ptr_previous_names;
13668         TALLOC_CTX *_mem_save_previous_names_0;
13669         uint32_t _ptr_manufacturer_name;
13670         TALLOC_CTX *_mem_save_manufacturer_name_0;
13671         uint32_t _ptr_manufacturer_url;
13672         TALLOC_CTX *_mem_save_manufacturer_url_0;
13673         uint32_t _ptr_hardware_id;
13674         TALLOC_CTX *_mem_save_hardware_id_0;
13675         uint32_t _ptr_provider;
13676         TALLOC_CTX *_mem_save_provider_0;
13677         uint32_t _ptr_print_processor;
13678         TALLOC_CTX *_mem_save_print_processor_0;
13679         uint32_t _ptr_vendor_setup;
13680         TALLOC_CTX *_mem_save_vendor_setup_0;
13681         uint32_t _ptr_color_profiles;
13682         TALLOC_CTX *_mem_save_color_profiles_0;
13683         uint32_t _ptr_inf_path;
13684         TALLOC_CTX *_mem_save_inf_path_0;
13685         uint32_t _ptr_core_driver_dependencies;
13686         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
13687         if (ndr_flags & NDR_SCALARS) {
13688                 NDR_CHECK(ndr_pull_align(ndr, 8));
13689                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
13690                 {
13691                         uint32_t _flags_save_string = ndr->flags;
13692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13693                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
13694                         if (_ptr_driver_name) {
13695                                 NDR_PULL_ALLOC(ndr, r->driver_name);
13696                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
13697                         } else {
13698                                 r->driver_name = NULL;
13699                         }
13700                         ndr->flags = _flags_save_string;
13701                 }
13702                 {
13703                         uint32_t _flags_save_string = ndr->flags;
13704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13705                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13706                         if (_ptr_architecture) {
13707                                 NDR_PULL_ALLOC(ndr, r->architecture);
13708                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
13709                         } else {
13710                                 r->architecture = NULL;
13711                         }
13712                         ndr->flags = _flags_save_string;
13713                 }
13714                 {
13715                         uint32_t _flags_save_string = ndr->flags;
13716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13717                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
13718                         if (_ptr_driver_path) {
13719                                 NDR_PULL_ALLOC(ndr, r->driver_path);
13720                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
13721                         } else {
13722                                 r->driver_path = NULL;
13723                         }
13724                         ndr->flags = _flags_save_string;
13725                 }
13726                 {
13727                         uint32_t _flags_save_string = ndr->flags;
13728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
13730                         if (_ptr_data_file) {
13731                                 NDR_PULL_ALLOC(ndr, r->data_file);
13732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
13733                         } else {
13734                                 r->data_file = NULL;
13735                         }
13736                         ndr->flags = _flags_save_string;
13737                 }
13738                 {
13739                         uint32_t _flags_save_string = ndr->flags;
13740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
13742                         if (_ptr_config_file) {
13743                                 NDR_PULL_ALLOC(ndr, r->config_file);
13744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
13745                         } else {
13746                                 r->config_file = NULL;
13747                         }
13748                         ndr->flags = _flags_save_string;
13749                 }
13750                 {
13751                         uint32_t _flags_save_string = ndr->flags;
13752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
13754                         if (_ptr_help_file) {
13755                                 NDR_PULL_ALLOC(ndr, r->help_file);
13756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
13757                         } else {
13758                                 r->help_file = NULL;
13759                         }
13760                         ndr->flags = _flags_save_string;
13761                 }
13762                 {
13763                         uint32_t _flags_save_string_array = ndr->flags;
13764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
13766                         if (_ptr_dependent_files) {
13767                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
13768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
13769                         } else {
13770                                 r->dependent_files = NULL;
13771                         }
13772                         ndr->flags = _flags_save_string_array;
13773                 }
13774                 {
13775                         uint32_t _flags_save_string = ndr->flags;
13776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
13778                         if (_ptr_monitor_name) {
13779                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
13780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
13781                         } else {
13782                                 r->monitor_name = NULL;
13783                         }
13784                         ndr->flags = _flags_save_string;
13785                 }
13786                 {
13787                         uint32_t _flags_save_string = ndr->flags;
13788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13789                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
13790                         if (_ptr_default_datatype) {
13791                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
13792                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
13793                         } else {
13794                                 r->default_datatype = NULL;
13795                         }
13796                         ndr->flags = _flags_save_string;
13797                 }
13798                 {
13799                         uint32_t _flags_save_string_array = ndr->flags;
13800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
13802                         if (_ptr_previous_names) {
13803                                 NDR_PULL_ALLOC(ndr, r->previous_names);
13804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
13805                         } else {
13806                                 r->previous_names = NULL;
13807                         }
13808                         ndr->flags = _flags_save_string_array;
13809                 }
13810                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
13811                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
13812                 {
13813                         uint32_t _flags_save_string = ndr->flags;
13814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
13816                         if (_ptr_manufacturer_name) {
13817                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
13818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
13819                         } else {
13820                                 r->manufacturer_name = NULL;
13821                         }
13822                         ndr->flags = _flags_save_string;
13823                 }
13824                 {
13825                         uint32_t _flags_save_string = ndr->flags;
13826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13827                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
13828                         if (_ptr_manufacturer_url) {
13829                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
13830                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
13831                         } else {
13832                                 r->manufacturer_url = NULL;
13833                         }
13834                         ndr->flags = _flags_save_string;
13835                 }
13836                 {
13837                         uint32_t _flags_save_string = ndr->flags;
13838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13839                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
13840                         if (_ptr_hardware_id) {
13841                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
13842                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
13843                         } else {
13844                                 r->hardware_id = NULL;
13845                         }
13846                         ndr->flags = _flags_save_string;
13847                 }
13848                 {
13849                         uint32_t _flags_save_string = ndr->flags;
13850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13851                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
13852                         if (_ptr_provider) {
13853                                 NDR_PULL_ALLOC(ndr, r->provider);
13854                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
13855                         } else {
13856                                 r->provider = NULL;
13857                         }
13858                         ndr->flags = _flags_save_string;
13859                 }
13860                 {
13861                         uint32_t _flags_save_string = ndr->flags;
13862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13863                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
13864                         if (_ptr_print_processor) {
13865                                 NDR_PULL_ALLOC(ndr, r->print_processor);
13866                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
13867                         } else {
13868                                 r->print_processor = NULL;
13869                         }
13870                         ndr->flags = _flags_save_string;
13871                 }
13872                 {
13873                         uint32_t _flags_save_string = ndr->flags;
13874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13875                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
13876                         if (_ptr_vendor_setup) {
13877                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
13878                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
13879                         } else {
13880                                 r->vendor_setup = NULL;
13881                         }
13882                         ndr->flags = _flags_save_string;
13883                 }
13884                 {
13885                         uint32_t _flags_save_string_array = ndr->flags;
13886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13887                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
13888                         if (_ptr_color_profiles) {
13889                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
13890                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
13891                         } else {
13892                                 r->color_profiles = NULL;
13893                         }
13894                         ndr->flags = _flags_save_string_array;
13895                 }
13896                 {
13897                         uint32_t _flags_save_string = ndr->flags;
13898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13899                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
13900                         if (_ptr_inf_path) {
13901                                 NDR_PULL_ALLOC(ndr, r->inf_path);
13902                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
13903                         } else {
13904                                 r->inf_path = NULL;
13905                         }
13906                         ndr->flags = _flags_save_string;
13907                 }
13908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
13909                 {
13910                         uint32_t _flags_save_string_array = ndr->flags;
13911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13912                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
13913                         if (_ptr_core_driver_dependencies) {
13914                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
13915                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
13916                         } else {
13917                                 r->core_driver_dependencies = NULL;
13918                         }
13919                         ndr->flags = _flags_save_string_array;
13920                 }
13921                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
13922                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
13923                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
13924         }
13925         if (ndr_flags & NDR_BUFFERS) {
13926                 {
13927                         uint32_t _flags_save_string = ndr->flags;
13928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13929                         if (r->driver_name) {
13930                                 uint32_t _relative_save_offset;
13931                                 _relative_save_offset = ndr->offset;
13932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
13933                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13934                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
13935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
13936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
13937                                 if (ndr->offset > ndr->relative_highest_offset) {
13938                                         ndr->relative_highest_offset = ndr->offset;
13939                                 }
13940                                 ndr->offset = _relative_save_offset;
13941                         }
13942                         ndr->flags = _flags_save_string;
13943                 }
13944                 {
13945                         uint32_t _flags_save_string = ndr->flags;
13946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13947                         if (r->architecture) {
13948                                 uint32_t _relative_save_offset;
13949                                 _relative_save_offset = ndr->offset;
13950                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
13951                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13952                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
13953                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
13954                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13955                                 if (ndr->offset > ndr->relative_highest_offset) {
13956                                         ndr->relative_highest_offset = ndr->offset;
13957                                 }
13958                                 ndr->offset = _relative_save_offset;
13959                         }
13960                         ndr->flags = _flags_save_string;
13961                 }
13962                 {
13963                         uint32_t _flags_save_string = ndr->flags;
13964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13965                         if (r->driver_path) {
13966                                 uint32_t _relative_save_offset;
13967                                 _relative_save_offset = ndr->offset;
13968                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
13969                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13970                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
13971                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
13972                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
13973                                 if (ndr->offset > ndr->relative_highest_offset) {
13974                                         ndr->relative_highest_offset = ndr->offset;
13975                                 }
13976                                 ndr->offset = _relative_save_offset;
13977                         }
13978                         ndr->flags = _flags_save_string;
13979                 }
13980                 {
13981                         uint32_t _flags_save_string = ndr->flags;
13982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13983                         if (r->data_file) {
13984                                 uint32_t _relative_save_offset;
13985                                 _relative_save_offset = ndr->offset;
13986                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
13987                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
13988                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
13989                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
13990                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
13991                                 if (ndr->offset > ndr->relative_highest_offset) {
13992                                         ndr->relative_highest_offset = ndr->offset;
13993                                 }
13994                                 ndr->offset = _relative_save_offset;
13995                         }
13996                         ndr->flags = _flags_save_string;
13997                 }
13998                 {
13999                         uint32_t _flags_save_string = ndr->flags;
14000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14001                         if (r->config_file) {
14002                                 uint32_t _relative_save_offset;
14003                                 _relative_save_offset = ndr->offset;
14004                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
14005                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14006                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
14007                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
14008                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
14009                                 if (ndr->offset > ndr->relative_highest_offset) {
14010                                         ndr->relative_highest_offset = ndr->offset;
14011                                 }
14012                                 ndr->offset = _relative_save_offset;
14013                         }
14014                         ndr->flags = _flags_save_string;
14015                 }
14016                 {
14017                         uint32_t _flags_save_string = ndr->flags;
14018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14019                         if (r->help_file) {
14020                                 uint32_t _relative_save_offset;
14021                                 _relative_save_offset = ndr->offset;
14022                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
14023                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14024                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
14025                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
14026                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
14027                                 if (ndr->offset > ndr->relative_highest_offset) {
14028                                         ndr->relative_highest_offset = ndr->offset;
14029                                 }
14030                                 ndr->offset = _relative_save_offset;
14031                         }
14032                         ndr->flags = _flags_save_string;
14033                 }
14034                 {
14035                         uint32_t _flags_save_string_array = ndr->flags;
14036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14037                         if (r->dependent_files) {
14038                                 uint32_t _relative_save_offset;
14039                                 _relative_save_offset = ndr->offset;
14040                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
14041                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
14042                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
14043                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
14044                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
14045                                 if (ndr->offset > ndr->relative_highest_offset) {
14046                                         ndr->relative_highest_offset = ndr->offset;
14047                                 }
14048                                 ndr->offset = _relative_save_offset;
14049                         }
14050                         ndr->flags = _flags_save_string_array;
14051                 }
14052                 {
14053                         uint32_t _flags_save_string = ndr->flags;
14054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14055                         if (r->monitor_name) {
14056                                 uint32_t _relative_save_offset;
14057                                 _relative_save_offset = ndr->offset;
14058                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14059                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14060                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14061                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14062                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14063                                 if (ndr->offset > ndr->relative_highest_offset) {
14064                                         ndr->relative_highest_offset = ndr->offset;
14065                                 }
14066                                 ndr->offset = _relative_save_offset;
14067                         }
14068                         ndr->flags = _flags_save_string;
14069                 }
14070                 {
14071                         uint32_t _flags_save_string = ndr->flags;
14072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14073                         if (r->default_datatype) {
14074                                 uint32_t _relative_save_offset;
14075                                 _relative_save_offset = ndr->offset;
14076                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
14077                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14078                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
14079                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
14080                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
14081                                 if (ndr->offset > ndr->relative_highest_offset) {
14082                                         ndr->relative_highest_offset = ndr->offset;
14083                                 }
14084                                 ndr->offset = _relative_save_offset;
14085                         }
14086                         ndr->flags = _flags_save_string;
14087                 }
14088                 {
14089                         uint32_t _flags_save_string_array = ndr->flags;
14090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14091                         if (r->previous_names) {
14092                                 uint32_t _relative_save_offset;
14093                                 _relative_save_offset = ndr->offset;
14094                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
14095                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
14096                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
14097                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
14098                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
14099                                 if (ndr->offset > ndr->relative_highest_offset) {
14100                                         ndr->relative_highest_offset = ndr->offset;
14101                                 }
14102                                 ndr->offset = _relative_save_offset;
14103                         }
14104                         ndr->flags = _flags_save_string_array;
14105                 }
14106                 {
14107                         uint32_t _flags_save_string = ndr->flags;
14108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14109                         if (r->manufacturer_name) {
14110                                 uint32_t _relative_save_offset;
14111                                 _relative_save_offset = ndr->offset;
14112                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
14113                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14114                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
14115                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
14116                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
14117                                 if (ndr->offset > ndr->relative_highest_offset) {
14118                                         ndr->relative_highest_offset = ndr->offset;
14119                                 }
14120                                 ndr->offset = _relative_save_offset;
14121                         }
14122                         ndr->flags = _flags_save_string;
14123                 }
14124                 {
14125                         uint32_t _flags_save_string = ndr->flags;
14126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14127                         if (r->manufacturer_url) {
14128                                 uint32_t _relative_save_offset;
14129                                 _relative_save_offset = ndr->offset;
14130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
14131                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
14132                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
14133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
14134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
14135                                 if (ndr->offset > ndr->relative_highest_offset) {
14136                                         ndr->relative_highest_offset = ndr->offset;
14137                                 }
14138                                 ndr->offset = _relative_save_offset;
14139                         }
14140                         ndr->flags = _flags_save_string;
14141                 }
14142                 {
14143                         uint32_t _flags_save_string = ndr->flags;
14144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14145                         if (r->hardware_id) {
14146                                 uint32_t _relative_save_offset;
14147                                 _relative_save_offset = ndr->offset;
14148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
14149                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
14150                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
14151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
14152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
14153                                 if (ndr->offset > ndr->relative_highest_offset) {
14154                                         ndr->relative_highest_offset = ndr->offset;
14155                                 }
14156                                 ndr->offset = _relative_save_offset;
14157                         }
14158                         ndr->flags = _flags_save_string;
14159                 }
14160                 {
14161                         uint32_t _flags_save_string = ndr->flags;
14162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14163                         if (r->provider) {
14164                                 uint32_t _relative_save_offset;
14165                                 _relative_save_offset = ndr->offset;
14166                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
14167                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
14168                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
14169                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
14170                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
14171                                 if (ndr->offset > ndr->relative_highest_offset) {
14172                                         ndr->relative_highest_offset = ndr->offset;
14173                                 }
14174                                 ndr->offset = _relative_save_offset;
14175                         }
14176                         ndr->flags = _flags_save_string;
14177                 }
14178                 {
14179                         uint32_t _flags_save_string = ndr->flags;
14180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14181                         if (r->print_processor) {
14182                                 uint32_t _relative_save_offset;
14183                                 _relative_save_offset = ndr->offset;
14184                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
14185                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
14186                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
14187                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
14188                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
14189                                 if (ndr->offset > ndr->relative_highest_offset) {
14190                                         ndr->relative_highest_offset = ndr->offset;
14191                                 }
14192                                 ndr->offset = _relative_save_offset;
14193                         }
14194                         ndr->flags = _flags_save_string;
14195                 }
14196                 {
14197                         uint32_t _flags_save_string = ndr->flags;
14198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14199                         if (r->vendor_setup) {
14200                                 uint32_t _relative_save_offset;
14201                                 _relative_save_offset = ndr->offset;
14202                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
14203                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
14204                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
14205                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
14206                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
14207                                 if (ndr->offset > ndr->relative_highest_offset) {
14208                                         ndr->relative_highest_offset = ndr->offset;
14209                                 }
14210                                 ndr->offset = _relative_save_offset;
14211                         }
14212                         ndr->flags = _flags_save_string;
14213                 }
14214                 {
14215                         uint32_t _flags_save_string_array = ndr->flags;
14216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14217                         if (r->color_profiles) {
14218                                 uint32_t _relative_save_offset;
14219                                 _relative_save_offset = ndr->offset;
14220                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
14221                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
14222                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
14223                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
14224                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
14225                                 if (ndr->offset > ndr->relative_highest_offset) {
14226                                         ndr->relative_highest_offset = ndr->offset;
14227                                 }
14228                                 ndr->offset = _relative_save_offset;
14229                         }
14230                         ndr->flags = _flags_save_string_array;
14231                 }
14232                 {
14233                         uint32_t _flags_save_string = ndr->flags;
14234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14235                         if (r->inf_path) {
14236                                 uint32_t _relative_save_offset;
14237                                 _relative_save_offset = ndr->offset;
14238                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
14239                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
14240                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
14241                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
14242                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
14243                                 if (ndr->offset > ndr->relative_highest_offset) {
14244                                         ndr->relative_highest_offset = ndr->offset;
14245                                 }
14246                                 ndr->offset = _relative_save_offset;
14247                         }
14248                         ndr->flags = _flags_save_string;
14249                 }
14250                 {
14251                         uint32_t _flags_save_string_array = ndr->flags;
14252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14253                         if (r->core_driver_dependencies) {
14254                                 uint32_t _relative_save_offset;
14255                                 _relative_save_offset = ndr->offset;
14256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
14257                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
14258                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
14259                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
14260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
14261                                 if (ndr->offset > ndr->relative_highest_offset) {
14262                                         ndr->relative_highest_offset = ndr->offset;
14263                                 }
14264                                 ndr->offset = _relative_save_offset;
14265                         }
14266                         ndr->flags = _flags_save_string_array;
14267                 }
14268         }
14269         return NDR_ERR_SUCCESS;
14270 }
14271
14272 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
14273 {
14274         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
14275         ndr->depth++;
14276         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14277         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14278         ndr->depth++;
14279         if (r->driver_name) {
14280                 ndr_print_string(ndr, "driver_name", r->driver_name);
14281         }
14282         ndr->depth--;
14283         ndr_print_ptr(ndr, "architecture", r->architecture);
14284         ndr->depth++;
14285         if (r->architecture) {
14286                 ndr_print_string(ndr, "architecture", r->architecture);
14287         }
14288         ndr->depth--;
14289         ndr_print_ptr(ndr, "driver_path", r->driver_path);
14290         ndr->depth++;
14291         if (r->driver_path) {
14292                 ndr_print_string(ndr, "driver_path", r->driver_path);
14293         }
14294         ndr->depth--;
14295         ndr_print_ptr(ndr, "data_file", r->data_file);
14296         ndr->depth++;
14297         if (r->data_file) {
14298                 ndr_print_string(ndr, "data_file", r->data_file);
14299         }
14300         ndr->depth--;
14301         ndr_print_ptr(ndr, "config_file", r->config_file);
14302         ndr->depth++;
14303         if (r->config_file) {
14304                 ndr_print_string(ndr, "config_file", r->config_file);
14305         }
14306         ndr->depth--;
14307         ndr_print_ptr(ndr, "help_file", r->help_file);
14308         ndr->depth++;
14309         if (r->help_file) {
14310                 ndr_print_string(ndr, "help_file", r->help_file);
14311         }
14312         ndr->depth--;
14313         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
14314         ndr->depth++;
14315         if (r->dependent_files) {
14316                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
14317         }
14318         ndr->depth--;
14319         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14320         ndr->depth++;
14321         if (r->monitor_name) {
14322                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14323         }
14324         ndr->depth--;
14325         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14326         ndr->depth++;
14327         if (r->default_datatype) {
14328                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14329         }
14330         ndr->depth--;
14331         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14332         ndr->depth++;
14333         if (r->previous_names) {
14334                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14335         }
14336         ndr->depth--;
14337         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14338         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14339         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14340         ndr->depth++;
14341         if (r->manufacturer_name) {
14342                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14343         }
14344         ndr->depth--;
14345         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14346         ndr->depth++;
14347         if (r->manufacturer_url) {
14348                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14349         }
14350         ndr->depth--;
14351         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14352         ndr->depth++;
14353         if (r->hardware_id) {
14354                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14355         }
14356         ndr->depth--;
14357         ndr_print_ptr(ndr, "provider", r->provider);
14358         ndr->depth++;
14359         if (r->provider) {
14360                 ndr_print_string(ndr, "provider", r->provider);
14361         }
14362         ndr->depth--;
14363         ndr_print_ptr(ndr, "print_processor", r->print_processor);
14364         ndr->depth++;
14365         if (r->print_processor) {
14366                 ndr_print_string(ndr, "print_processor", r->print_processor);
14367         }
14368         ndr->depth--;
14369         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
14370         ndr->depth++;
14371         if (r->vendor_setup) {
14372                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
14373         }
14374         ndr->depth--;
14375         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
14376         ndr->depth++;
14377         if (r->color_profiles) {
14378                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
14379         }
14380         ndr->depth--;
14381         ndr_print_ptr(ndr, "inf_path", r->inf_path);
14382         ndr->depth++;
14383         if (r->inf_path) {
14384                 ndr_print_string(ndr, "inf_path", r->inf_path);
14385         }
14386         ndr->depth--;
14387         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
14388         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14389         ndr->depth++;
14390         if (r->core_driver_dependencies) {
14391                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
14392         }
14393         ndr->depth--;
14394         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
14395         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
14396         ndr->depth--;
14397 }
14398
14399 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
14400 {
14401         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
14402 }
14403
14404 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
14405 {
14406         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
14407         return NDR_ERR_SUCCESS;
14408 }
14409
14410 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
14411 {
14412         uint32_t v;
14413         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
14414         *r = v;
14415         return NDR_ERR_SUCCESS;
14416 }
14417
14418 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
14419 {
14420         const char *val = NULL;
14421
14422         switch (r) {
14423                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
14424                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
14425                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
14426                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
14427                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
14428         }
14429         ndr_print_enum(ndr, name, "ENUM", val, r);
14430 }
14431
14432 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
14433 {
14434         if (ndr_flags & NDR_SCALARS) {
14435                 NDR_CHECK(ndr_push_align(ndr, 5));
14436                 {
14437                         uint32_t _flags_save_string = ndr->flags;
14438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
14440                         ndr->flags = _flags_save_string;
14441                 }
14442                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
14443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
14444                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
14445         }
14446         if (ndr_flags & NDR_BUFFERS) {
14447                 {
14448                         uint32_t _flags_save_string = ndr->flags;
14449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14450                         if (r->file_name) {
14451                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
14452                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
14453                         }
14454                         ndr->flags = _flags_save_string;
14455                 }
14456         }
14457         return NDR_ERR_SUCCESS;
14458 }
14459
14460 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
14461 {
14462         uint32_t _ptr_file_name;
14463         TALLOC_CTX *_mem_save_file_name_0;
14464         if (ndr_flags & NDR_SCALARS) {
14465                 NDR_CHECK(ndr_pull_align(ndr, 5));
14466                 {
14467                         uint32_t _flags_save_string = ndr->flags;
14468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14469                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
14470                         if (_ptr_file_name) {
14471                                 NDR_PULL_ALLOC(ndr, r->file_name);
14472                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
14473                         } else {
14474                                 r->file_name = NULL;
14475                         }
14476                         ndr->flags = _flags_save_string;
14477                 }
14478                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
14479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
14480                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
14481         }
14482         if (ndr_flags & NDR_BUFFERS) {
14483                 {
14484                         uint32_t _flags_save_string = ndr->flags;
14485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14486                         if (r->file_name) {
14487                                 uint32_t _relative_save_offset;
14488                                 _relative_save_offset = ndr->offset;
14489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
14490                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14491                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
14492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
14493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
14494                                 if (ndr->offset > ndr->relative_highest_offset) {
14495                                         ndr->relative_highest_offset = ndr->offset;
14496                                 }
14497                                 ndr->offset = _relative_save_offset;
14498                         }
14499                         ndr->flags = _flags_save_string;
14500                 }
14501         }
14502         return NDR_ERR_SUCCESS;
14503 }
14504
14505 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
14506 {
14507         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
14508         ndr->depth++;
14509         ndr_print_ptr(ndr, "file_name", r->file_name);
14510         ndr->depth++;
14511         if (r->file_name) {
14512                 ndr_print_string(ndr, "file_name", r->file_name);
14513         }
14514         ndr->depth--;
14515         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
14516         ndr_print_uint32(ndr, "file_version", r->file_version);
14517         ndr->depth--;
14518 }
14519
14520 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
14521 {
14522         uint32_t cntr_file_info_1;
14523         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
14524         ndr->depth++;
14525         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
14526         ndr_print_ptr(ndr, "driver_name", r->driver_name);
14527         ndr->depth++;
14528         if (r->driver_name) {
14529                 ndr_print_string(ndr, "driver_name", r->driver_name);
14530         }
14531         ndr->depth--;
14532         ndr_print_ptr(ndr, "architecture", r->architecture);
14533         ndr->depth++;
14534         if (r->architecture) {
14535                 ndr_print_string(ndr, "architecture", r->architecture);
14536         }
14537         ndr->depth--;
14538         ndr_print_ptr(ndr, "file_info", r->file_info);
14539         ndr->depth++;
14540         if (r->file_info) {
14541                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
14542                 ndr->depth++;
14543                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
14544                         char *idx_1=NULL;
14545                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
14546                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
14547                                 free(idx_1);
14548                         }
14549                 }
14550                 ndr->depth--;
14551         }
14552         ndr->depth--;
14553         ndr_print_uint32(ndr, "file_count", r->file_count);
14554         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14555         ndr->depth++;
14556         if (r->monitor_name) {
14557                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14558         }
14559         ndr->depth--;
14560         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
14561         ndr->depth++;
14562         if (r->default_datatype) {
14563                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
14564         }
14565         ndr->depth--;
14566         ndr_print_ptr(ndr, "previous_names", r->previous_names);
14567         ndr->depth++;
14568         if (r->previous_names) {
14569                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
14570         }
14571         ndr->depth--;
14572         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
14573         ndr_print_hyper(ndr, "driver_version", r->driver_version);
14574         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
14575         ndr->depth++;
14576         if (r->manufacturer_name) {
14577                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
14578         }
14579         ndr->depth--;
14580         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
14581         ndr->depth++;
14582         if (r->manufacturer_url) {
14583                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
14584         }
14585         ndr->depth--;
14586         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
14587         ndr->depth++;
14588         if (r->hardware_id) {
14589                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
14590         }
14591         ndr->depth--;
14592         ndr_print_ptr(ndr, "provider", r->provider);
14593         ndr->depth++;
14594         if (r->provider) {
14595                 ndr_print_string(ndr, "provider", r->provider);
14596         }
14597         ndr->depth--;
14598         ndr->depth--;
14599 }
14600
14601 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
14602 {
14603         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
14604 }
14605
14606 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
14607 {
14608         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14609         if (ndr_flags & NDR_SCALARS) {
14610                 int level = ndr_push_get_switch_value(ndr, r);
14611                 NDR_CHECK(ndr_push_union_align(ndr, 8));
14612                 switch (level) {
14613                         case 1: {
14614                                 NDR_CHECK(ndr_push_align(ndr, 5));
14615                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14616                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14617                         break; }
14618
14619                         case 2: {
14620                                 NDR_CHECK(ndr_push_align(ndr, 5));
14621                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14622                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14623                         break; }
14624
14625                         case 3: {
14626                                 NDR_CHECK(ndr_push_align(ndr, 5));
14627                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14628                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14629                         break; }
14630
14631                         case 4: {
14632                                 NDR_CHECK(ndr_push_align(ndr, 5));
14633                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14634                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14635                         break; }
14636
14637                         case 5: {
14638                                 NDR_CHECK(ndr_push_align(ndr, 5));
14639                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14640                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14641                         break; }
14642
14643                         case 6: {
14644                                 NDR_CHECK(ndr_push_align(ndr, 8));
14645                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14646                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14647                         break; }
14648
14649                         case 7: {
14650                                 NDR_CHECK(ndr_push_align(ndr, 5));
14651                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14652                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14653                         break; }
14654
14655                         case 8: {
14656                                 NDR_CHECK(ndr_push_align(ndr, 8));
14657                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14658                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14659                         break; }
14660
14661                         case 101: {
14662                                 NDR_CHECK(ndr_push_align(ndr, 8));
14663                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14664                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14665                         break; }
14666
14667                         default: {
14668                         break; }
14669
14670                 }
14671         }
14672         if (ndr_flags & NDR_BUFFERS) {
14673                 int level = ndr_push_get_switch_value(ndr, r);
14674                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14675                 switch (level) {
14676                         case 1:
14677                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14678                         break;
14679
14680                         case 2:
14681                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14682                         break;
14683
14684                         case 3:
14685                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14686                         break;
14687
14688                         case 4:
14689                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14690                         break;
14691
14692                         case 5:
14693                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14694                         break;
14695
14696                         case 6:
14697                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14698                         break;
14699
14700                         case 7:
14701                                 NDR_CHECK(ndr_push_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14702                         break;
14703
14704                         case 8:
14705                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14706                         break;
14707
14708                         case 101:
14709                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14710                         break;
14711
14712                         default:
14713                         break;
14714
14715                 }
14716         }
14717         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14718         return NDR_ERR_SUCCESS;
14719 }
14720
14721 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
14722 {
14723         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14724         int level;
14725         level = ndr_pull_get_switch_value(ndr, r);
14726         if (ndr_flags & NDR_SCALARS) {
14727                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
14728                 switch (level) {
14729                         case 1: {
14730                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14731                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14732                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
14733                         break; }
14734
14735                         case 2: {
14736                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14737                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14738                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
14739                         break; }
14740
14741                         case 3: {
14742                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14743                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14744                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
14745                         break; }
14746
14747                         case 4: {
14748                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14749                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14750                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
14751                         break; }
14752
14753                         case 5: {
14754                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14755                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14756                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
14757                         break; }
14758
14759                         case 6: {
14760                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14761                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14762                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
14763                         break; }
14764
14765                         case 7: {
14766                                 NDR_CHECK(ndr_pull_align(ndr, 5));
14767                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14768                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_SCALARS, &r->info7));
14769                         break; }
14770
14771                         case 8: {
14772                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14773                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14774                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
14775                         break; }
14776
14777                         case 101: {
14778                                 NDR_CHECK(ndr_pull_align(ndr, 8));
14779                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14780                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
14781                         break; }
14782
14783                         default: {
14784                         break; }
14785
14786                 }
14787         }
14788         if (ndr_flags & NDR_BUFFERS) {
14789                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14790                 switch (level) {
14791                         case 1:
14792                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
14793                         break;
14794
14795                         case 2:
14796                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
14797                         break;
14798
14799                         case 3:
14800                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
14801                         break;
14802
14803                         case 4:
14804                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
14805                         break;
14806
14807                         case 5:
14808                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
14809                         break;
14810
14811                         case 6:
14812                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
14813                         break;
14814
14815                         case 7:
14816                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo7(ndr, NDR_BUFFERS, &r->info7));
14817                         break;
14818
14819                         case 8:
14820                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
14821                         break;
14822
14823                         case 101:
14824                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
14825                         break;
14826
14827                         default:
14828                         break;
14829
14830                 }
14831         }
14832         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14833         return NDR_ERR_SUCCESS;
14834 }
14835
14836 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
14837 {
14838         int level;
14839         level = ndr_print_get_switch_value(ndr, r);
14840         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
14841         switch (level) {
14842                 case 1:
14843                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
14844                 break;
14845
14846                 case 2:
14847                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
14848                 break;
14849
14850                 case 3:
14851                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
14852                 break;
14853
14854                 case 4:
14855                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
14856                 break;
14857
14858                 case 5:
14859                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
14860                 break;
14861
14862                 case 6:
14863                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
14864                 break;
14865
14866                 case 7:
14867                         ndr_print_spoolss_DriverInfo7(ndr, "info7", &r->info7);
14868                 break;
14869
14870                 case 8:
14871                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
14872                 break;
14873
14874                 case 101:
14875                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
14876                 break;
14877
14878                 default:
14879                 break;
14880
14881         }
14882 }
14883
14884 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14885 {
14886         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
14887 }
14888
14889 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
14890 {
14891         if (ndr_flags & NDR_SCALARS) {
14892                 NDR_CHECK(ndr_push_align(ndr, 4));
14893                 {
14894                         uint32_t _flags_save_string = ndr->flags;
14895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14896                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14897                         ndr->flags = _flags_save_string;
14898                 }
14899                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
14900         }
14901         if (ndr_flags & NDR_BUFFERS) {
14902         }
14903         return NDR_ERR_SUCCESS;
14904 }
14905
14906 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
14907 {
14908         if (ndr_flags & NDR_SCALARS) {
14909                 NDR_CHECK(ndr_pull_align(ndr, 4));
14910                 {
14911                         uint32_t _flags_save_string = ndr->flags;
14912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14913                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14914                         ndr->flags = _flags_save_string;
14915                 }
14916                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
14917         }
14918         if (ndr_flags & NDR_BUFFERS) {
14919         }
14920         return NDR_ERR_SUCCESS;
14921 }
14922
14923 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
14924 {
14925         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
14926         ndr->depth++;
14927         ndr_print_string(ndr, "directory_name", r->directory_name);
14928         ndr->depth--;
14929 }
14930
14931 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14932 {
14933         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
14934 }
14935
14936 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
14937 {
14938         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14939         if (ndr_flags & NDR_SCALARS) {
14940                 int level = ndr_push_get_switch_value(ndr, r);
14941                 NDR_CHECK(ndr_push_union_align(ndr, 4));
14942                 switch (level) {
14943                         case 1: {
14944                                 NDR_CHECK(ndr_push_align(ndr, 4));
14945                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14946                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14947                         break; }
14948
14949                         default: {
14950                                 NDR_CHECK(ndr_push_align(ndr, 4));
14951                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14952                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14953                         break; }
14954
14955                 }
14956         }
14957         if (ndr_flags & NDR_BUFFERS) {
14958                 int level = ndr_push_get_switch_value(ndr, r);
14959                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14960                 switch (level) {
14961                         case 1:
14962                         break;
14963
14964                         default:
14965                         break;
14966
14967                 }
14968         }
14969         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14970         return NDR_ERR_SUCCESS;
14971 }
14972
14973 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
14974 {
14975         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14976         int level;
14977         level = ndr_pull_get_switch_value(ndr, r);
14978         if (ndr_flags & NDR_SCALARS) {
14979                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
14980                 switch (level) {
14981                         case 1: {
14982                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14983                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14984                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14985                         break; }
14986
14987                         default: {
14988                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14989                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14990                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14991                         break; }
14992
14993                 }
14994         }
14995         if (ndr_flags & NDR_BUFFERS) {
14996                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14997                 switch (level) {
14998                         case 1:
14999                         break;
15000
15001                         default:
15002                         break;
15003
15004                 }
15005         }
15006         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15007         return NDR_ERR_SUCCESS;
15008 }
15009
15010 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
15011 {
15012         int level;
15013         level = ndr_print_get_switch_value(ndr, r);
15014         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
15015         switch (level) {
15016                 case 1:
15017                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15018                 break;
15019
15020                 default:
15021                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
15022                 break;
15023
15024         }
15025 }
15026
15027 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15028 {
15029         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
15030 }
15031
15032 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
15033 {
15034         if (ndr_flags & NDR_SCALARS) {
15035                 NDR_CHECK(ndr_push_align(ndr, 5));
15036                 {
15037                         uint32_t _flags_save_string = ndr->flags;
15038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15039                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
15040                         ndr->flags = _flags_save_string;
15041                 }
15042                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15043         }
15044         if (ndr_flags & NDR_BUFFERS) {
15045                 {
15046                         uint32_t _flags_save_string = ndr->flags;
15047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15048                         if (r->print_processor_name) {
15049                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
15050                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
15051                         }
15052                         ndr->flags = _flags_save_string;
15053                 }
15054         }
15055         return NDR_ERR_SUCCESS;
15056 }
15057
15058 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
15059 {
15060         uint32_t _ptr_print_processor_name;
15061         TALLOC_CTX *_mem_save_print_processor_name_0;
15062         if (ndr_flags & NDR_SCALARS) {
15063                 NDR_CHECK(ndr_pull_align(ndr, 5));
15064                 {
15065                         uint32_t _flags_save_string = ndr->flags;
15066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15067                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
15068                         if (_ptr_print_processor_name) {
15069                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
15070                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
15071                         } else {
15072                                 r->print_processor_name = NULL;
15073                         }
15074                         ndr->flags = _flags_save_string;
15075                 }
15076                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15077         }
15078         if (ndr_flags & NDR_BUFFERS) {
15079                 {
15080                         uint32_t _flags_save_string = ndr->flags;
15081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15082                         if (r->print_processor_name) {
15083                                 uint32_t _relative_save_offset;
15084                                 _relative_save_offset = ndr->offset;
15085                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
15086                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15087                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
15088                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
15089                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
15090                                 if (ndr->offset > ndr->relative_highest_offset) {
15091                                         ndr->relative_highest_offset = ndr->offset;
15092                                 }
15093                                 ndr->offset = _relative_save_offset;
15094                         }
15095                         ndr->flags = _flags_save_string;
15096                 }
15097         }
15098         return NDR_ERR_SUCCESS;
15099 }
15100
15101 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
15102 {
15103         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
15104         ndr->depth++;
15105         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
15106         ndr->depth++;
15107         if (r->print_processor_name) {
15108                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
15109         }
15110         ndr->depth--;
15111         ndr->depth--;
15112 }
15113
15114 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15115 {
15116         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
15117 }
15118
15119 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
15120 {
15121         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15122         if (ndr_flags & NDR_SCALARS) {
15123                 int level = ndr_push_get_switch_value(ndr, r);
15124                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15125                 switch (level) {
15126                         case 1: {
15127                                 NDR_CHECK(ndr_push_align(ndr, 5));
15128                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15129                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15130                         break; }
15131
15132                         default: {
15133                         break; }
15134
15135                 }
15136         }
15137         if (ndr_flags & NDR_BUFFERS) {
15138                 int level = ndr_push_get_switch_value(ndr, r);
15139                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15140                 switch (level) {
15141                         case 1:
15142                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15143                         break;
15144
15145                         default:
15146                         break;
15147
15148                 }
15149         }
15150         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15151         return NDR_ERR_SUCCESS;
15152 }
15153
15154 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
15155 {
15156         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15157         int level;
15158         level = ndr_pull_get_switch_value(ndr, r);
15159         if (ndr_flags & NDR_SCALARS) {
15160                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15161                 switch (level) {
15162                         case 1: {
15163                                 NDR_CHECK(ndr_pull_align(ndr, 5));
15164                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15165                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
15166                         break; }
15167
15168                         default: {
15169                         break; }
15170
15171                 }
15172         }
15173         if (ndr_flags & NDR_BUFFERS) {
15174                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15175                 switch (level) {
15176                         case 1:
15177                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
15178                         break;
15179
15180                         default:
15181                         break;
15182
15183                 }
15184         }
15185         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15186         return NDR_ERR_SUCCESS;
15187 }
15188
15189 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
15190 {
15191         int level;
15192         level = ndr_print_get_switch_value(ndr, r);
15193         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
15194         switch (level) {
15195                 case 1:
15196                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
15197                 break;
15198
15199                 default:
15200                 break;
15201
15202         }
15203 }
15204
15205 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15206 {
15207         if (ndr_flags & NDR_SCALARS) {
15208                 NDR_CHECK(ndr_push_align(ndr, 4));
15209                 {
15210                         uint32_t _flags_save_string = ndr->flags;
15211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15212                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
15213                         ndr->flags = _flags_save_string;
15214                 }
15215                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15216         }
15217         if (ndr_flags & NDR_BUFFERS) {
15218         }
15219         return NDR_ERR_SUCCESS;
15220 }
15221
15222 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
15223 {
15224         if (ndr_flags & NDR_SCALARS) {
15225                 NDR_CHECK(ndr_pull_align(ndr, 4));
15226                 {
15227                         uint32_t _flags_save_string = ndr->flags;
15228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15229                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
15230                         ndr->flags = _flags_save_string;
15231                 }
15232                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15233         }
15234         if (ndr_flags & NDR_BUFFERS) {
15235         }
15236         return NDR_ERR_SUCCESS;
15237 }
15238
15239 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
15240 {
15241         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
15242         ndr->depth++;
15243         ndr_print_string(ndr, "directory_name", r->directory_name);
15244         ndr->depth--;
15245 }
15246
15247 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15248 {
15249         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
15250 }
15251
15252 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
15253 {
15254         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15255         if (ndr_flags & NDR_SCALARS) {
15256                 int level = ndr_push_get_switch_value(ndr, r);
15257                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15258                 switch (level) {
15259                         case 1: {
15260                                 NDR_CHECK(ndr_push_align(ndr, 4));
15261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15262                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15263                         break; }
15264
15265                         default: {
15266                                 NDR_CHECK(ndr_push_align(ndr, 4));
15267                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15268                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15269                         break; }
15270
15271                 }
15272         }
15273         if (ndr_flags & NDR_BUFFERS) {
15274                 int level = ndr_push_get_switch_value(ndr, r);
15275                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15276                 switch (level) {
15277                         case 1:
15278                         break;
15279
15280                         default:
15281                         break;
15282
15283                 }
15284         }
15285         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15286         return NDR_ERR_SUCCESS;
15287 }
15288
15289 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
15290 {
15291         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15292         int level;
15293         level = ndr_pull_get_switch_value(ndr, r);
15294         if (ndr_flags & NDR_SCALARS) {
15295                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15296                 switch (level) {
15297                         case 1: {
15298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15300                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15301                         break; }
15302
15303                         default: {
15304                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15305                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15306                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
15307                         break; }
15308
15309                 }
15310         }
15311         if (ndr_flags & NDR_BUFFERS) {
15312                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15313                 switch (level) {
15314                         case 1:
15315                         break;
15316
15317                         default:
15318                         break;
15319
15320                 }
15321         }
15322         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15323         return NDR_ERR_SUCCESS;
15324 }
15325
15326 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
15327 {
15328         int level;
15329         level = ndr_print_get_switch_value(ndr, r);
15330         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
15331         switch (level) {
15332                 case 1:
15333                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15334                 break;
15335
15336                 default:
15337                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
15338                 break;
15339
15340         }
15341 }
15342
15343 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15344 {
15345         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
15346 }
15347
15348 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
15349 {
15350         if (ndr_flags & NDR_SCALARS) {
15351                 NDR_CHECK(ndr_push_align(ndr, 5));
15352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
15353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
15354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
15355                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
15356         }
15357         if (ndr_flags & NDR_BUFFERS) {
15358                 if (r->document_name) {
15359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
15362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15363                 }
15364                 if (r->output_file) {
15365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
15368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15369                 }
15370                 if (r->datatype) {
15371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
15373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
15374                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15375                 }
15376         }
15377         return NDR_ERR_SUCCESS;
15378 }
15379
15380 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
15381 {
15382         uint32_t _ptr_document_name;
15383         TALLOC_CTX *_mem_save_document_name_0;
15384         uint32_t _ptr_output_file;
15385         TALLOC_CTX *_mem_save_output_file_0;
15386         uint32_t _ptr_datatype;
15387         TALLOC_CTX *_mem_save_datatype_0;
15388         if (ndr_flags & NDR_SCALARS) {
15389                 NDR_CHECK(ndr_pull_align(ndr, 5));
15390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
15391                 if (_ptr_document_name) {
15392                         NDR_PULL_ALLOC(ndr, r->document_name);
15393                 } else {
15394                         r->document_name = NULL;
15395                 }
15396                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
15397                 if (_ptr_output_file) {
15398                         NDR_PULL_ALLOC(ndr, r->output_file);
15399                 } else {
15400                         r->output_file = NULL;
15401                 }
15402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15403                 if (_ptr_datatype) {
15404                         NDR_PULL_ALLOC(ndr, r->datatype);
15405                 } else {
15406                         r->datatype = NULL;
15407                 }
15408                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
15409         }
15410         if (ndr_flags & NDR_BUFFERS) {
15411                 if (r->document_name) {
15412                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15413                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
15414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
15415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
15416                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
15417                                 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));
15418                         }
15419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
15420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
15421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
15422                 }
15423                 if (r->output_file) {
15424                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
15425                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
15426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
15427                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
15428                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
15429                                 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));
15430                         }
15431                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
15432                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
15433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
15434                 }
15435                 if (r->datatype) {
15436                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15437                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
15438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
15439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
15440                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
15441                                 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));
15442                         }
15443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
15444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
15445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15446                 }
15447         }
15448         return NDR_ERR_SUCCESS;
15449 }
15450
15451 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
15452 {
15453         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
15454         ndr->depth++;
15455         ndr_print_ptr(ndr, "document_name", r->document_name);
15456         ndr->depth++;
15457         if (r->document_name) {
15458                 ndr_print_string(ndr, "document_name", r->document_name);
15459         }
15460         ndr->depth--;
15461         ndr_print_ptr(ndr, "output_file", r->output_file);
15462         ndr->depth++;
15463         if (r->output_file) {
15464                 ndr_print_string(ndr, "output_file", r->output_file);
15465         }
15466         ndr->depth--;
15467         ndr_print_ptr(ndr, "datatype", r->datatype);
15468         ndr->depth++;
15469         if (r->datatype) {
15470                 ndr_print_string(ndr, "datatype", r->datatype);
15471         }
15472         ndr->depth--;
15473         ndr->depth--;
15474 }
15475
15476 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
15477 {
15478         if (ndr_flags & NDR_SCALARS) {
15479                 int level = ndr_push_get_switch_value(ndr, r);
15480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15481                 NDR_CHECK(ndr_push_union_align(ndr, 5));
15482                 switch (level) {
15483                         case 1: {
15484                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15485                         break; }
15486
15487                         case 2: {
15488                         break; }
15489
15490                         case 3: {
15491                         break; }
15492
15493                         default: {
15494                         break; }
15495
15496                 }
15497         }
15498         if (ndr_flags & NDR_BUFFERS) {
15499                 int level = ndr_push_get_switch_value(ndr, r);
15500                 switch (level) {
15501                         case 1:
15502                                 if (r->info1) {
15503                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15504                                 }
15505                         break;
15506
15507                         case 2:
15508                         break;
15509
15510                         case 3:
15511                         break;
15512
15513                         default:
15514                         break;
15515
15516                 }
15517         }
15518         return NDR_ERR_SUCCESS;
15519 }
15520
15521 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
15522 {
15523         int level;
15524         uint32_t _level;
15525         TALLOC_CTX *_mem_save_info1_0;
15526         level = ndr_pull_get_switch_value(ndr, r);
15527         if (ndr_flags & NDR_SCALARS) {
15528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15529                 if (_level != level) {
15530                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
15531                 }
15532                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
15533                 switch (level) {
15534                         case 1: {
15535                                 uint32_t _ptr_info1;
15536                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15537                                 if (_ptr_info1) {
15538                                         NDR_PULL_ALLOC(ndr, r->info1);
15539                                 } else {
15540                                         r->info1 = NULL;
15541                                 }
15542                         break; }
15543
15544                         case 2: {
15545                         break; }
15546
15547                         case 3: {
15548                         break; }
15549
15550                         default: {
15551                         break; }
15552
15553                 }
15554         }
15555         if (ndr_flags & NDR_BUFFERS) {
15556                 switch (level) {
15557                         case 1:
15558                                 if (r->info1) {
15559                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15560                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15561                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15562                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15563                                 }
15564                         break;
15565
15566                         case 2:
15567                         break;
15568
15569                         case 3:
15570                         break;
15571
15572                         default:
15573                         break;
15574
15575                 }
15576         }
15577         return NDR_ERR_SUCCESS;
15578 }
15579
15580 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
15581 {
15582         int level;
15583         level = ndr_print_get_switch_value(ndr, r);
15584         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
15585         switch (level) {
15586                 case 1:
15587                         ndr_print_ptr(ndr, "info1", r->info1);
15588                         ndr->depth++;
15589                         if (r->info1) {
15590                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
15591                         }
15592                         ndr->depth--;
15593                 break;
15594
15595                 case 2:
15596                 break;
15597
15598                 case 3:
15599                 break;
15600
15601                 default:
15602                 break;
15603
15604         }
15605 }
15606
15607 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
15608 {
15609         if (ndr_flags & NDR_SCALARS) {
15610                 NDR_CHECK(ndr_push_align(ndr, 4));
15611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
15612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15616                 {
15617                         uint32_t _flags_save_string = ndr->flags;
15618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15619                         {
15620                                 struct ndr_push *_ndr_extra_string;
15621                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15622                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15623                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15624                         }
15625                         ndr->flags = _flags_save_string;
15626                 }
15627                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15628         }
15629         if (ndr_flags & NDR_BUFFERS) {
15630         }
15631         return NDR_ERR_SUCCESS;
15632 }
15633
15634 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
15635 {
15636         if (ndr_flags & NDR_SCALARS) {
15637                 NDR_CHECK(ndr_pull_align(ndr, 4));
15638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15643                 {
15644                         uint32_t _flags_save_string = ndr->flags;
15645                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15646                         {
15647                                 struct ndr_pull *_ndr_extra_string;
15648                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15649                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15650                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15651                         }
15652                         ndr->flags = _flags_save_string;
15653                 }
15654                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15655         }
15656         if (ndr_flags & NDR_BUFFERS) {
15657         }
15658         return NDR_ERR_SUCCESS;
15659 }
15660
15661 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
15662 {
15663         ndr_print_struct(ndr, name, "spoolss_OSVersion");
15664         ndr->depth++;
15665         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);
15666         ndr_print_uint32(ndr, "major", r->major);
15667         ndr_print_uint32(ndr, "minor", r->minor);
15668         ndr_print_uint32(ndr, "build", r->build);
15669         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15670         ndr_print_string(ndr, "extra_string", r->extra_string);
15671         ndr->depth--;
15672 }
15673
15674 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
15675 {
15676         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
15677 }
15678
15679 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
15680 {
15681         if (ndr_flags & NDR_SCALARS) {
15682                 NDR_CHECK(ndr_push_align(ndr, 4));
15683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
15684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
15685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
15686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15688                 {
15689                         uint32_t _flags_save_string = ndr->flags;
15690                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15691                         {
15692                                 struct ndr_push *_ndr_extra_string;
15693                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15694                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
15695                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15696                         }
15697                         ndr->flags = _flags_save_string;
15698                 }
15699                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_major));
15700                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->service_pack_minor));
15701                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->suite_mask));
15702                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->product_type));
15703                 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, r->reserved));
15704                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15705         }
15706         if (ndr_flags & NDR_BUFFERS) {
15707         }
15708         return NDR_ERR_SUCCESS;
15709 }
15710
15711 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
15712 {
15713         if (ndr_flags & NDR_SCALARS) {
15714                 NDR_CHECK(ndr_pull_align(ndr, 4));
15715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
15716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
15717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
15718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->platform_id));
15720                 {
15721                         uint32_t _flags_save_string = ndr->flags;
15722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15723                         {
15724                                 struct ndr_pull *_ndr_extra_string;
15725                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
15726                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
15727                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
15728                         }
15729                         ndr->flags = _flags_save_string;
15730                 }
15731                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_major));
15732                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->service_pack_minor));
15733                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->suite_mask));
15734                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->product_type));
15735                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->reserved));
15736                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15737         }
15738         if (ndr_flags & NDR_BUFFERS) {
15739         }
15740         return NDR_ERR_SUCCESS;
15741 }
15742
15743 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
15744 {
15745         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
15746         ndr->depth++;
15747         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);
15748         ndr_print_uint32(ndr, "major", r->major);
15749         ndr_print_uint32(ndr, "minor", r->minor);
15750         ndr_print_uint32(ndr, "build", r->build);
15751         ndr_print_uint32(ndr, "platform_id", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->platform_id);
15752         ndr_print_string(ndr, "extra_string", r->extra_string);
15753         ndr_print_uint16(ndr, "service_pack_major", r->service_pack_major);
15754         ndr_print_uint16(ndr, "service_pack_minor", r->service_pack_minor);
15755         ndr_print_uint16(ndr, "suite_mask", r->suite_mask);
15756         ndr_print_uint8(ndr, "product_type", r->product_type);
15757         ndr_print_uint8(ndr, "reserved", r->reserved);
15758         ndr->depth--;
15759 }
15760
15761 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
15762 {
15763         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
15764 }
15765
15766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
15767 {
15768         if (ndr_flags & NDR_SCALARS) {
15769                 int level = ndr_push_get_switch_value(ndr, r);
15770                 NDR_CHECK(ndr_push_union_align(ndr, 4));
15771                 switch (level) {
15772                         case REG_NONE: {
15773                         break; }
15774
15775                         case REG_SZ: {
15776                                 {
15777                                         uint32_t _flags_save_string = ndr->flags;
15778                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15779                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
15780                                         ndr->flags = _flags_save_string;
15781                                 }
15782                         break; }
15783
15784                         case REG_BINARY: {
15785                                 {
15786                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15787                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15788                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
15789                                         ndr->flags = _flags_save_DATA_BLOB;
15790                                 }
15791                         break; }
15792
15793                         case REG_DWORD: {
15794                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
15795                         break; }
15796
15797                         case REG_MULTI_SZ: {
15798                                 {
15799                                         uint32_t _flags_save_string_array = ndr->flags;
15800                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15801                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
15802                                         ndr->flags = _flags_save_string_array;
15803                                 }
15804                         break; }
15805
15806                         default: {
15807                                 {
15808                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15809                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15810                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
15811                                         ndr->flags = _flags_save_DATA_BLOB;
15812                                 }
15813                         break; }
15814
15815                 }
15816         }
15817         if (ndr_flags & NDR_BUFFERS) {
15818                 int level = ndr_push_get_switch_value(ndr, r);
15819                 switch (level) {
15820                         case REG_NONE:
15821                         break;
15822
15823                         case REG_SZ:
15824                         break;
15825
15826                         case REG_BINARY:
15827                         break;
15828
15829                         case REG_DWORD:
15830                         break;
15831
15832                         case REG_MULTI_SZ:
15833                         break;
15834
15835                         default:
15836                         break;
15837
15838                 }
15839         }
15840         return NDR_ERR_SUCCESS;
15841 }
15842
15843 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
15844 {
15845         int level;
15846         level = ndr_pull_get_switch_value(ndr, r);
15847         if (ndr_flags & NDR_SCALARS) {
15848                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
15849                 switch (level) {
15850                         case REG_NONE: {
15851                         break; }
15852
15853                         case REG_SZ: {
15854                                 {
15855                                         uint32_t _flags_save_string = ndr->flags;
15856                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15857                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
15858                                         ndr->flags = _flags_save_string;
15859                                 }
15860                         break; }
15861
15862                         case REG_BINARY: {
15863                                 {
15864                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15865                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15866                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
15867                                         ndr->flags = _flags_save_DATA_BLOB;
15868                                 }
15869                         break; }
15870
15871                         case REG_DWORD: {
15872                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
15873                         break; }
15874
15875                         case REG_MULTI_SZ: {
15876                                 {
15877                                         uint32_t _flags_save_string_array = ndr->flags;
15878                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15879                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
15880                                         ndr->flags = _flags_save_string_array;
15881                                 }
15882                         break; }
15883
15884                         default: {
15885                                 {
15886                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
15887                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
15888                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
15889                                         ndr->flags = _flags_save_DATA_BLOB;
15890                                 }
15891                         break; }
15892
15893                 }
15894         }
15895         if (ndr_flags & NDR_BUFFERS) {
15896                 switch (level) {
15897                         case REG_NONE:
15898                         break;
15899
15900                         case REG_SZ:
15901                         break;
15902
15903                         case REG_BINARY:
15904                         break;
15905
15906                         case REG_DWORD:
15907                         break;
15908
15909                         case REG_MULTI_SZ:
15910                         break;
15911
15912                         default:
15913                         break;
15914
15915                 }
15916         }
15917         return NDR_ERR_SUCCESS;
15918 }
15919
15920 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
15921 {
15922         int level;
15923         level = ndr_print_get_switch_value(ndr, r);
15924         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
15925         switch (level) {
15926                 case REG_NONE:
15927                 break;
15928
15929                 case REG_SZ:
15930                         ndr_print_string(ndr, "string", r->string);
15931                 break;
15932
15933                 case REG_BINARY:
15934                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
15935                 break;
15936
15937                 case REG_DWORD:
15938                         ndr_print_uint32(ndr, "value", r->value);
15939                 break;
15940
15941                 case REG_MULTI_SZ:
15942                         ndr_print_string_array(ndr, "string_array", r->string_array);
15943                 break;
15944
15945                 default:
15946                         ndr_print_DATA_BLOB(ndr, "data", r->data);
15947                 break;
15948
15949         }
15950 }
15951
15952 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
15953 {
15954         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
15955         return NDR_ERR_SUCCESS;
15956 }
15957
15958 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
15959 {
15960         uint32_t v;
15961         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
15962         *r = v;
15963         return NDR_ERR_SUCCESS;
15964 }
15965
15966 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
15967 {
15968         const char *val = NULL;
15969
15970         switch (r) {
15971                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
15972                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
15973                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
15974         }
15975         ndr_print_enum(ndr, name, "ENUM", val, r);
15976 }
15977
15978 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
15979 {
15980         if (ndr_flags & NDR_SCALARS) {
15981                 NDR_CHECK(ndr_push_align(ndr, 4));
15982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
15983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
15984                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
15985         }
15986         if (ndr_flags & NDR_BUFFERS) {
15987         }
15988         return NDR_ERR_SUCCESS;
15989 }
15990
15991 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
15992 {
15993         if (ndr_flags & NDR_SCALARS) {
15994                 NDR_CHECK(ndr_pull_align(ndr, 4));
15995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
15996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
15997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
15998         }
15999         if (ndr_flags & NDR_BUFFERS) {
16000         }
16001         return NDR_ERR_SUCCESS;
16002 }
16003
16004 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
16005 {
16006         ndr_print_struct(ndr, name, "spoolss_FormSize");
16007         ndr->depth++;
16008         ndr_print_uint32(ndr, "width", r->width);
16009         ndr_print_uint32(ndr, "height", r->height);
16010         ndr->depth--;
16011 }
16012
16013 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
16014 {
16015         if (ndr_flags & NDR_SCALARS) {
16016                 NDR_CHECK(ndr_push_align(ndr, 4));
16017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
16018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
16019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
16020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
16021                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
16022         }
16023         if (ndr_flags & NDR_BUFFERS) {
16024         }
16025         return NDR_ERR_SUCCESS;
16026 }
16027
16028 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
16029 {
16030         if (ndr_flags & NDR_SCALARS) {
16031                 NDR_CHECK(ndr_pull_align(ndr, 4));
16032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
16033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
16034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
16035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
16036                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
16037         }
16038         if (ndr_flags & NDR_BUFFERS) {
16039         }
16040         return NDR_ERR_SUCCESS;
16041 }
16042
16043 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
16044 {
16045         ndr_print_struct(ndr, name, "spoolss_FormArea");
16046         ndr->depth++;
16047         ndr_print_uint32(ndr, "left", r->left);
16048         ndr_print_uint32(ndr, "top", r->top);
16049         ndr_print_uint32(ndr, "right", r->right);
16050         ndr_print_uint32(ndr, "bottom", r->bottom);
16051         ndr->depth--;
16052 }
16053
16054 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
16055 {
16056         if (ndr_flags & NDR_SCALARS) {
16057                 NDR_CHECK(ndr_push_align(ndr, 5));
16058                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16059                 {
16060                         uint32_t _flags_save_string = ndr->flags;
16061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16062                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16063                         ndr->flags = _flags_save_string;
16064                 }
16065                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16066                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16067                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16068         }
16069         if (ndr_flags & NDR_BUFFERS) {
16070                 {
16071                         uint32_t _flags_save_string = ndr->flags;
16072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16073                         if (r->form_name) {
16074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
16075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16076                         }
16077                         ndr->flags = _flags_save_string;
16078                 }
16079         }
16080         return NDR_ERR_SUCCESS;
16081 }
16082
16083 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
16084 {
16085         uint32_t _ptr_form_name;
16086         TALLOC_CTX *_mem_save_form_name_0;
16087         if (ndr_flags & NDR_SCALARS) {
16088                 NDR_CHECK(ndr_pull_align(ndr, 5));
16089                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16090                 {
16091                         uint32_t _flags_save_string = ndr->flags;
16092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16093                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16094                         if (_ptr_form_name) {
16095                                 NDR_PULL_ALLOC(ndr, r->form_name);
16096                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16097                         } else {
16098                                 r->form_name = NULL;
16099                         }
16100                         ndr->flags = _flags_save_string;
16101                 }
16102                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16103                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16104                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16105         }
16106         if (ndr_flags & NDR_BUFFERS) {
16107                 {
16108                         uint32_t _flags_save_string = ndr->flags;
16109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16110                         if (r->form_name) {
16111                                 uint32_t _relative_save_offset;
16112                                 _relative_save_offset = ndr->offset;
16113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16114                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16115                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16116                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16118                                 if (ndr->offset > ndr->relative_highest_offset) {
16119                                         ndr->relative_highest_offset = ndr->offset;
16120                                 }
16121                                 ndr->offset = _relative_save_offset;
16122                         }
16123                         ndr->flags = _flags_save_string;
16124                 }
16125         }
16126         return NDR_ERR_SUCCESS;
16127 }
16128
16129 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
16130 {
16131         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
16132         ndr->depth++;
16133         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16134         ndr_print_ptr(ndr, "form_name", r->form_name);
16135         ndr->depth++;
16136         if (r->form_name) {
16137                 ndr_print_string(ndr, "form_name", r->form_name);
16138         }
16139         ndr->depth--;
16140         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16141         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16142         ndr->depth--;
16143 }
16144
16145 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16146 {
16147         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
16148 }
16149
16150 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16151 {
16152         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16153         return NDR_ERR_SUCCESS;
16154 }
16155
16156 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16157 {
16158         uint32_t v;
16159         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16160         *r = v;
16161         return NDR_ERR_SUCCESS;
16162 }
16163
16164 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
16165 {
16166         ndr_print_uint32(ndr, name, r);
16167         ndr->depth++;
16168         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
16169         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
16170         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
16171         ndr->depth--;
16172 }
16173
16174 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
16175 {
16176         if (ndr_flags & NDR_SCALARS) {
16177                 NDR_CHECK(ndr_push_align(ndr, 5));
16178                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16179                 {
16180                         uint32_t _flags_save_string = ndr->flags;
16181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16182                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
16183                         ndr->flags = _flags_save_string;
16184                 }
16185                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16186                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16187                 {
16188                         uint32_t _flags_save_string = ndr->flags;
16189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
16191                         ndr->flags = _flags_save_string;
16192                 }
16193                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16194                 {
16195                         uint32_t _flags_save_string = ndr->flags;
16196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
16198                         ndr->flags = _flags_save_string;
16199                 }
16200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16201                 {
16202                         uint32_t _flags_save_string = ndr->flags;
16203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16204                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
16205                         ndr->flags = _flags_save_string;
16206                 }
16207                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->lang_id));
16208                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unused));
16209                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16210         }
16211         if (ndr_flags & NDR_BUFFERS) {
16212                 {
16213                         uint32_t _flags_save_string = ndr->flags;
16214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16215                         if (r->form_name) {
16216                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
16217                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
16218                         }
16219                         ndr->flags = _flags_save_string;
16220                 }
16221                 {
16222                         uint32_t _flags_save_string = ndr->flags;
16223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16224                         if (r->keyword) {
16225                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
16226                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
16227                         }
16228                         ndr->flags = _flags_save_string;
16229                 }
16230                 {
16231                         uint32_t _flags_save_string = ndr->flags;
16232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16233                         if (r->mui_dll) {
16234                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
16235                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
16236                         }
16237                         ndr->flags = _flags_save_string;
16238                 }
16239                 {
16240                         uint32_t _flags_save_string = ndr->flags;
16241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16242                         if (r->display_name) {
16243                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
16244                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
16245                         }
16246                         ndr->flags = _flags_save_string;
16247                 }
16248         }
16249         return NDR_ERR_SUCCESS;
16250 }
16251
16252 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
16253 {
16254         uint32_t _ptr_form_name;
16255         TALLOC_CTX *_mem_save_form_name_0;
16256         uint32_t _ptr_keyword;
16257         TALLOC_CTX *_mem_save_keyword_0;
16258         uint32_t _ptr_mui_dll;
16259         TALLOC_CTX *_mem_save_mui_dll_0;
16260         uint32_t _ptr_display_name;
16261         TALLOC_CTX *_mem_save_display_name_0;
16262         if (ndr_flags & NDR_SCALARS) {
16263                 NDR_CHECK(ndr_pull_align(ndr, 5));
16264                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16265                 {
16266                         uint32_t _flags_save_string = ndr->flags;
16267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16268                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16269                         if (_ptr_form_name) {
16270                                 NDR_PULL_ALLOC(ndr, r->form_name);
16271                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
16272                         } else {
16273                                 r->form_name = NULL;
16274                         }
16275                         ndr->flags = _flags_save_string;
16276                 }
16277                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16278                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16279                 {
16280                         uint32_t _flags_save_string = ndr->flags;
16281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16282                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16283                         if (_ptr_keyword) {
16284                                 NDR_PULL_ALLOC(ndr, r->keyword);
16285                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
16286                         } else {
16287                                 r->keyword = NULL;
16288                         }
16289                         ndr->flags = _flags_save_string;
16290                 }
16291                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16292                 {
16293                         uint32_t _flags_save_string = ndr->flags;
16294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16295                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16296                         if (_ptr_mui_dll) {
16297                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
16298                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
16299                         } else {
16300                                 r->mui_dll = NULL;
16301                         }
16302                         ndr->flags = _flags_save_string;
16303                 }
16304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16305                 {
16306                         uint32_t _flags_save_string = ndr->flags;
16307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16308                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16309                         if (_ptr_display_name) {
16310                                 NDR_PULL_ALLOC(ndr, r->display_name);
16311                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
16312                         } else {
16313                                 r->display_name = NULL;
16314                         }
16315                         ndr->flags = _flags_save_string;
16316                 }
16317                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->lang_id));
16318                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unused));
16319                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16320         }
16321         if (ndr_flags & NDR_BUFFERS) {
16322                 {
16323                         uint32_t _flags_save_string = ndr->flags;
16324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16325                         if (r->form_name) {
16326                                 uint32_t _relative_save_offset;
16327                                 _relative_save_offset = ndr->offset;
16328                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
16329                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16330                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16331                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
16332                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16333                                 if (ndr->offset > ndr->relative_highest_offset) {
16334                                         ndr->relative_highest_offset = ndr->offset;
16335                                 }
16336                                 ndr->offset = _relative_save_offset;
16337                         }
16338                         ndr->flags = _flags_save_string;
16339                 }
16340                 {
16341                         uint32_t _flags_save_string = ndr->flags;
16342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
16343                         if (r->keyword) {
16344                                 uint32_t _relative_save_offset;
16345                                 _relative_save_offset = ndr->offset;
16346                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
16347                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16348                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16349                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
16350                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16351                                 if (ndr->offset > ndr->relative_highest_offset) {
16352                                         ndr->relative_highest_offset = ndr->offset;
16353                                 }
16354                                 ndr->offset = _relative_save_offset;
16355                         }
16356                         ndr->flags = _flags_save_string;
16357                 }
16358                 {
16359                         uint32_t _flags_save_string = ndr->flags;
16360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16361                         if (r->mui_dll) {
16362                                 uint32_t _relative_save_offset;
16363                                 _relative_save_offset = ndr->offset;
16364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
16365                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16366                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
16368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16369                                 if (ndr->offset > ndr->relative_highest_offset) {
16370                                         ndr->relative_highest_offset = ndr->offset;
16371                                 }
16372                                 ndr->offset = _relative_save_offset;
16373                         }
16374                         ndr->flags = _flags_save_string;
16375                 }
16376                 {
16377                         uint32_t _flags_save_string = ndr->flags;
16378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16379                         if (r->display_name) {
16380                                 uint32_t _relative_save_offset;
16381                                 _relative_save_offset = ndr->offset;
16382                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
16383                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16384                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16385                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
16386                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16387                                 if (ndr->offset > ndr->relative_highest_offset) {
16388                                         ndr->relative_highest_offset = ndr->offset;
16389                                 }
16390                                 ndr->offset = _relative_save_offset;
16391                         }
16392                         ndr->flags = _flags_save_string;
16393                 }
16394         }
16395         return NDR_ERR_SUCCESS;
16396 }
16397
16398 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
16399 {
16400         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
16401         ndr->depth++;
16402         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16403         ndr_print_ptr(ndr, "form_name", r->form_name);
16404         ndr->depth++;
16405         if (r->form_name) {
16406                 ndr_print_string(ndr, "form_name", r->form_name);
16407         }
16408         ndr->depth--;
16409         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16410         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16411         ndr_print_ptr(ndr, "keyword", r->keyword);
16412         ndr->depth++;
16413         if (r->keyword) {
16414                 ndr_print_string(ndr, "keyword", r->keyword);
16415         }
16416         ndr->depth--;
16417         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16418         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16419         ndr->depth++;
16420         if (r->mui_dll) {
16421                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16422         }
16423         ndr->depth--;
16424         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16425         ndr_print_ptr(ndr, "display_name", r->display_name);
16426         ndr->depth++;
16427         if (r->display_name) {
16428                 ndr_print_string(ndr, "display_name", r->display_name);
16429         }
16430         ndr->depth--;
16431         ndr_print_uint16(ndr, "lang_id", r->lang_id);
16432         ndr_print_uint16(ndr, "unused", r->unused);
16433         ndr->depth--;
16434 }
16435
16436 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16437 {
16438         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
16439 }
16440
16441 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
16442 {
16443         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16444         if (ndr_flags & NDR_SCALARS) {
16445                 int level = ndr_push_get_switch_value(ndr, r);
16446                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16447                 switch (level) {
16448                         case 1: {
16449                                 NDR_CHECK(ndr_push_align(ndr, 5));
16450                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16451                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16452                         break; }
16453
16454                         case 2: {
16455                                 NDR_CHECK(ndr_push_align(ndr, 5));
16456                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16457                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16458                         break; }
16459
16460                         default: {
16461                         break; }
16462
16463                 }
16464         }
16465         if (ndr_flags & NDR_BUFFERS) {
16466                 int level = ndr_push_get_switch_value(ndr, r);
16467                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16468                 switch (level) {
16469                         case 1:
16470                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16471                         break;
16472
16473                         case 2:
16474                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16475                         break;
16476
16477                         default:
16478                         break;
16479
16480                 }
16481         }
16482         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16483         return NDR_ERR_SUCCESS;
16484 }
16485
16486 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
16487 {
16488         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16489         int level;
16490         level = ndr_pull_get_switch_value(ndr, r);
16491         if (ndr_flags & NDR_SCALARS) {
16492                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16493                 switch (level) {
16494                         case 1: {
16495                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16496                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16497                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
16498                         break; }
16499
16500                         case 2: {
16501                                 NDR_CHECK(ndr_pull_align(ndr, 5));
16502                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16503                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
16504                         break; }
16505
16506                         default: {
16507                         break; }
16508
16509                 }
16510         }
16511         if (ndr_flags & NDR_BUFFERS) {
16512                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16513                 switch (level) {
16514                         case 1:
16515                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
16516                         break;
16517
16518                         case 2:
16519                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
16520                         break;
16521
16522                         default:
16523                         break;
16524
16525                 }
16526         }
16527         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16528         return NDR_ERR_SUCCESS;
16529 }
16530
16531 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
16532 {
16533         int level;
16534         level = ndr_print_get_switch_value(ndr, r);
16535         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
16536         switch (level) {
16537                 case 1:
16538                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
16539                 break;
16540
16541                 case 2:
16542                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
16543                 break;
16544
16545                 default:
16546                 break;
16547
16548         }
16549 }
16550
16551 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
16552 {
16553         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
16554 }
16555
16556 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
16557 {
16558         if (ndr_flags & NDR_SCALARS) {
16559                 NDR_CHECK(ndr_push_align(ndr, 5));
16560                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16562                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16563                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16564                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16565         }
16566         if (ndr_flags & NDR_BUFFERS) {
16567                 if (r->form_name) {
16568                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16569                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16570                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16571                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16572                 }
16573         }
16574         return NDR_ERR_SUCCESS;
16575 }
16576
16577 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
16578 {
16579         uint32_t _ptr_form_name;
16580         TALLOC_CTX *_mem_save_form_name_0;
16581         if (ndr_flags & NDR_SCALARS) {
16582                 NDR_CHECK(ndr_pull_align(ndr, 5));
16583                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16585                 if (_ptr_form_name) {
16586                         NDR_PULL_ALLOC(ndr, r->form_name);
16587                 } else {
16588                         r->form_name = NULL;
16589                 }
16590                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16591                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16592                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16593         }
16594         if (ndr_flags & NDR_BUFFERS) {
16595                 if (r->form_name) {
16596                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16597                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16598                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16599                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16600                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16601                                 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));
16602                         }
16603                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16604                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16606                 }
16607         }
16608         return NDR_ERR_SUCCESS;
16609 }
16610
16611 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
16612 {
16613         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
16614         ndr->depth++;
16615         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16616         ndr_print_ptr(ndr, "form_name", r->form_name);
16617         ndr->depth++;
16618         if (r->form_name) {
16619                 ndr_print_string(ndr, "form_name", r->form_name);
16620         }
16621         ndr->depth--;
16622         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16623         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16624         ndr->depth--;
16625 }
16626
16627 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
16628 {
16629         if (ndr_flags & NDR_SCALARS) {
16630                 NDR_CHECK(ndr_push_align(ndr, 5));
16631                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
16632                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
16633                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16634                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
16636                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
16637                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
16638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
16639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
16640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
16641                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16642         }
16643         if (ndr_flags & NDR_BUFFERS) {
16644                 if (r->form_name) {
16645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
16648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16649                 }
16650                 if (r->keyword) {
16651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
16654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
16655                 }
16656                 if (r->mui_dll) {
16657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
16660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16661                 }
16662                 if (r->display_name) {
16663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
16665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
16666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16667                 }
16668         }
16669         return NDR_ERR_SUCCESS;
16670 }
16671
16672 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
16673 {
16674         uint32_t _ptr_form_name;
16675         TALLOC_CTX *_mem_save_form_name_0;
16676         uint32_t _ptr_keyword;
16677         TALLOC_CTX *_mem_save_keyword_0;
16678         uint32_t _ptr_mui_dll;
16679         TALLOC_CTX *_mem_save_mui_dll_0;
16680         uint32_t _ptr_display_name;
16681         TALLOC_CTX *_mem_save_display_name_0;
16682         if (ndr_flags & NDR_SCALARS) {
16683                 NDR_CHECK(ndr_pull_align(ndr, 5));
16684                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
16685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
16686                 if (_ptr_form_name) {
16687                         NDR_PULL_ALLOC(ndr, r->form_name);
16688                 } else {
16689                         r->form_name = NULL;
16690                 }
16691                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
16692                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
16693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
16694                 if (_ptr_keyword) {
16695                         NDR_PULL_ALLOC(ndr, r->keyword);
16696                 } else {
16697                         r->keyword = NULL;
16698                 }
16699                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
16700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
16701                 if (_ptr_mui_dll) {
16702                         NDR_PULL_ALLOC(ndr, r->mui_dll);
16703                 } else {
16704                         r->mui_dll = NULL;
16705                 }
16706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
16707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
16708                 if (_ptr_display_name) {
16709                         NDR_PULL_ALLOC(ndr, r->display_name);
16710                 } else {
16711                         r->display_name = NULL;
16712                 }
16713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
16714                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16715         }
16716         if (ndr_flags & NDR_BUFFERS) {
16717                 if (r->form_name) {
16718                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16719                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
16720                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
16721                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
16722                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
16723                                 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));
16724                         }
16725                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
16726                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
16727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
16728                 }
16729                 if (r->keyword) {
16730                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
16731                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
16732                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
16733                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
16734                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
16735                                 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));
16736                         }
16737                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
16738                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
16739                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
16740                 }
16741                 if (r->mui_dll) {
16742                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
16743                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
16744                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
16745                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
16746                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
16747                                 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));
16748                         }
16749                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
16750                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
16751                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
16752                 }
16753                 if (r->display_name) {
16754                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16755                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
16756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
16757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
16758                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
16759                                 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));
16760                         }
16761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
16762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
16763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
16764                 }
16765         }
16766         return NDR_ERR_SUCCESS;
16767 }
16768
16769 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
16770 {
16771         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
16772         ndr->depth++;
16773         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
16774         ndr_print_ptr(ndr, "form_name", r->form_name);
16775         ndr->depth++;
16776         if (r->form_name) {
16777                 ndr_print_string(ndr, "form_name", r->form_name);
16778         }
16779         ndr->depth--;
16780         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
16781         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
16782         ndr_print_ptr(ndr, "keyword", r->keyword);
16783         ndr->depth++;
16784         if (r->keyword) {
16785                 ndr_print_string(ndr, "keyword", r->keyword);
16786         }
16787         ndr->depth--;
16788         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
16789         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
16790         ndr->depth++;
16791         if (r->mui_dll) {
16792                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
16793         }
16794         ndr->depth--;
16795         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
16796         ndr_print_ptr(ndr, "display_name", r->display_name);
16797         ndr->depth++;
16798         if (r->display_name) {
16799                 ndr_print_string(ndr, "display_name", r->display_name);
16800         }
16801         ndr->depth--;
16802         ndr_print_uint32(ndr, "lang_id", r->lang_id);
16803         ndr->depth--;
16804 }
16805
16806 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
16807 {
16808         if (ndr_flags & NDR_SCALARS) {
16809                 int level = ndr_push_get_switch_value(ndr, r);
16810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16811                 NDR_CHECK(ndr_push_union_align(ndr, 5));
16812                 switch (level) {
16813                         case 1: {
16814                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
16815                         break; }
16816
16817                         case 2: {
16818                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
16819                         break; }
16820
16821                         default:
16822                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16823                 }
16824         }
16825         if (ndr_flags & NDR_BUFFERS) {
16826                 int level = ndr_push_get_switch_value(ndr, r);
16827                 switch (level) {
16828                         case 1:
16829                                 if (r->info1) {
16830                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16831                                 }
16832                         break;
16833
16834                         case 2:
16835                                 if (r->info2) {
16836                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16837                                 }
16838                         break;
16839
16840                         default:
16841                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16842                 }
16843         }
16844         return NDR_ERR_SUCCESS;
16845 }
16846
16847 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
16848 {
16849         int level;
16850         uint32_t _level;
16851         TALLOC_CTX *_mem_save_info1_0;
16852         TALLOC_CTX *_mem_save_info2_0;
16853         level = ndr_pull_get_switch_value(ndr, r);
16854         if (ndr_flags & NDR_SCALARS) {
16855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16856                 if (_level != level) {
16857                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
16858                 }
16859                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
16860                 switch (level) {
16861                         case 1: {
16862                                 uint32_t _ptr_info1;
16863                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
16864                                 if (_ptr_info1) {
16865                                         NDR_PULL_ALLOC(ndr, r->info1);
16866                                 } else {
16867                                         r->info1 = NULL;
16868                                 }
16869                         break; }
16870
16871                         case 2: {
16872                                 uint32_t _ptr_info2;
16873                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
16874                                 if (_ptr_info2) {
16875                                         NDR_PULL_ALLOC(ndr, r->info2);
16876                                 } else {
16877                                         r->info2 = NULL;
16878                                 }
16879                         break; }
16880
16881                         default:
16882                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16883                 }
16884         }
16885         if (ndr_flags & NDR_BUFFERS) {
16886                 switch (level) {
16887                         case 1:
16888                                 if (r->info1) {
16889                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16890                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
16891                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
16892                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
16893                                 }
16894                         break;
16895
16896                         case 2:
16897                                 if (r->info2) {
16898                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16899                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
16900                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
16901                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
16902                                 }
16903                         break;
16904
16905                         default:
16906                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
16907                 }
16908         }
16909         return NDR_ERR_SUCCESS;
16910 }
16911
16912 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
16913 {
16914         int level;
16915         level = ndr_print_get_switch_value(ndr, r);
16916         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
16917         switch (level) {
16918                 case 1:
16919                         ndr_print_ptr(ndr, "info1", r->info1);
16920                         ndr->depth++;
16921                         if (r->info1) {
16922                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
16923                         }
16924                         ndr->depth--;
16925                 break;
16926
16927                 case 2:
16928                         ndr_print_ptr(ndr, "info2", r->info2);
16929                         ndr->depth++;
16930                         if (r->info2) {
16931                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
16932                         }
16933                         ndr->depth--;
16934                 break;
16935
16936                 default:
16937                         ndr_print_bad_level(ndr, name, level);
16938         }
16939 }
16940
16941 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
16942 {
16943         if (ndr_flags & NDR_SCALARS) {
16944                 NDR_CHECK(ndr_push_align(ndr, 5));
16945                 {
16946                         uint32_t _flags_save_string = ndr->flags;
16947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16949                         ndr->flags = _flags_save_string;
16950                 }
16951                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
16952         }
16953         if (ndr_flags & NDR_BUFFERS) {
16954                 {
16955                         uint32_t _flags_save_string = ndr->flags;
16956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16957                         if (r->port_name) {
16958                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16959                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16960                         }
16961                         ndr->flags = _flags_save_string;
16962                 }
16963         }
16964         return NDR_ERR_SUCCESS;
16965 }
16966
16967 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
16968 {
16969         uint32_t _ptr_port_name;
16970         TALLOC_CTX *_mem_save_port_name_0;
16971         if (ndr_flags & NDR_SCALARS) {
16972                 NDR_CHECK(ndr_pull_align(ndr, 5));
16973                 {
16974                         uint32_t _flags_save_string = ndr->flags;
16975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16977                         if (_ptr_port_name) {
16978                                 NDR_PULL_ALLOC(ndr, r->port_name);
16979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16980                         } else {
16981                                 r->port_name = NULL;
16982                         }
16983                         ndr->flags = _flags_save_string;
16984                 }
16985                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
16986         }
16987         if (ndr_flags & NDR_BUFFERS) {
16988                 {
16989                         uint32_t _flags_save_string = ndr->flags;
16990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16991                         if (r->port_name) {
16992                                 uint32_t _relative_save_offset;
16993                                 _relative_save_offset = ndr->offset;
16994                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16995                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16996                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16997                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16998                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16999                                 if (ndr->offset > ndr->relative_highest_offset) {
17000                                         ndr->relative_highest_offset = ndr->offset;
17001                                 }
17002                                 ndr->offset = _relative_save_offset;
17003                         }
17004                         ndr->flags = _flags_save_string;
17005                 }
17006         }
17007         return NDR_ERR_SUCCESS;
17008 }
17009
17010 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
17011 {
17012         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
17013         ndr->depth++;
17014         ndr_print_ptr(ndr, "port_name", r->port_name);
17015         ndr->depth++;
17016         if (r->port_name) {
17017                 ndr_print_string(ndr, "port_name", r->port_name);
17018         }
17019         ndr->depth--;
17020         ndr->depth--;
17021 }
17022
17023 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17024 {
17025         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
17026 }
17027
17028 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17029 {
17030         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17031         return NDR_ERR_SUCCESS;
17032 }
17033
17034 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17035 {
17036         uint32_t v;
17037         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17038         *r = v;
17039         return NDR_ERR_SUCCESS;
17040 }
17041
17042 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
17043 {
17044         ndr_print_uint32(ndr, name, r);
17045         ndr->depth++;
17046         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
17047         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
17048         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
17049         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
17050         ndr->depth--;
17051 }
17052
17053 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
17054 {
17055         if (ndr_flags & NDR_SCALARS) {
17056                 NDR_CHECK(ndr_push_align(ndr, 5));
17057                 {
17058                         uint32_t _flags_save_string = ndr->flags;
17059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17060                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17061                         ndr->flags = _flags_save_string;
17062                 }
17063                 {
17064                         uint32_t _flags_save_string = ndr->flags;
17065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17066                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17067                         ndr->flags = _flags_save_string;
17068                 }
17069                 {
17070                         uint32_t _flags_save_string = ndr->flags;
17071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17072                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
17073                         ndr->flags = _flags_save_string;
17074                 }
17075                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
17076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
17077                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17078         }
17079         if (ndr_flags & NDR_BUFFERS) {
17080                 {
17081                         uint32_t _flags_save_string = ndr->flags;
17082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17083                         if (r->port_name) {
17084                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17085                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17086                         }
17087                         ndr->flags = _flags_save_string;
17088                 }
17089                 {
17090                         uint32_t _flags_save_string = ndr->flags;
17091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17092                         if (r->monitor_name) {
17093                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17094                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17095                         }
17096                         ndr->flags = _flags_save_string;
17097                 }
17098                 {
17099                         uint32_t _flags_save_string = ndr->flags;
17100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17101                         if (r->description) {
17102                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
17103                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
17104                         }
17105                         ndr->flags = _flags_save_string;
17106                 }
17107         }
17108         return NDR_ERR_SUCCESS;
17109 }
17110
17111 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
17112 {
17113         uint32_t _ptr_port_name;
17114         TALLOC_CTX *_mem_save_port_name_0;
17115         uint32_t _ptr_monitor_name;
17116         TALLOC_CTX *_mem_save_monitor_name_0;
17117         uint32_t _ptr_description;
17118         TALLOC_CTX *_mem_save_description_0;
17119         if (ndr_flags & NDR_SCALARS) {
17120                 NDR_CHECK(ndr_pull_align(ndr, 5));
17121                 {
17122                         uint32_t _flags_save_string = ndr->flags;
17123                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17124                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17125                         if (_ptr_port_name) {
17126                                 NDR_PULL_ALLOC(ndr, r->port_name);
17127                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17128                         } else {
17129                                 r->port_name = NULL;
17130                         }
17131                         ndr->flags = _flags_save_string;
17132                 }
17133                 {
17134                         uint32_t _flags_save_string = ndr->flags;
17135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17136                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17137                         if (_ptr_monitor_name) {
17138                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17139                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17140                         } else {
17141                                 r->monitor_name = NULL;
17142                         }
17143                         ndr->flags = _flags_save_string;
17144                 }
17145                 {
17146                         uint32_t _flags_save_string = ndr->flags;
17147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17148                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
17149                         if (_ptr_description) {
17150                                 NDR_PULL_ALLOC(ndr, r->description);
17151                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
17152                         } else {
17153                                 r->description = NULL;
17154                         }
17155                         ndr->flags = _flags_save_string;
17156                 }
17157                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
17158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
17159                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17160         }
17161         if (ndr_flags & NDR_BUFFERS) {
17162                 {
17163                         uint32_t _flags_save_string = ndr->flags;
17164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17165                         if (r->port_name) {
17166                                 uint32_t _relative_save_offset;
17167                                 _relative_save_offset = ndr->offset;
17168                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17169                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17170                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17171                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17172                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17173                                 if (ndr->offset > ndr->relative_highest_offset) {
17174                                         ndr->relative_highest_offset = ndr->offset;
17175                                 }
17176                                 ndr->offset = _relative_save_offset;
17177                         }
17178                         ndr->flags = _flags_save_string;
17179                 }
17180                 {
17181                         uint32_t _flags_save_string = ndr->flags;
17182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17183                         if (r->monitor_name) {
17184                                 uint32_t _relative_save_offset;
17185                                 _relative_save_offset = ndr->offset;
17186                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17187                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17188                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17189                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17190                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17191                                 if (ndr->offset > ndr->relative_highest_offset) {
17192                                         ndr->relative_highest_offset = ndr->offset;
17193                                 }
17194                                 ndr->offset = _relative_save_offset;
17195                         }
17196                         ndr->flags = _flags_save_string;
17197                 }
17198                 {
17199                         uint32_t _flags_save_string = ndr->flags;
17200                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17201                         if (r->description) {
17202                                 uint32_t _relative_save_offset;
17203                                 _relative_save_offset = ndr->offset;
17204                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
17205                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
17206                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
17207                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
17208                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
17209                                 if (ndr->offset > ndr->relative_highest_offset) {
17210                                         ndr->relative_highest_offset = ndr->offset;
17211                                 }
17212                                 ndr->offset = _relative_save_offset;
17213                         }
17214                         ndr->flags = _flags_save_string;
17215                 }
17216         }
17217         return NDR_ERR_SUCCESS;
17218 }
17219
17220 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
17221 {
17222         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
17223         ndr->depth++;
17224         ndr_print_ptr(ndr, "port_name", r->port_name);
17225         ndr->depth++;
17226         if (r->port_name) {
17227                 ndr_print_string(ndr, "port_name", r->port_name);
17228         }
17229         ndr->depth--;
17230         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17231         ndr->depth++;
17232         if (r->monitor_name) {
17233                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17234         }
17235         ndr->depth--;
17236         ndr_print_ptr(ndr, "description", r->description);
17237         ndr->depth++;
17238         if (r->description) {
17239                 ndr_print_string(ndr, "description", r->description);
17240         }
17241         ndr->depth--;
17242         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
17243         ndr_print_uint32(ndr, "reserved", r->reserved);
17244         ndr->depth--;
17245 }
17246
17247 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17248 {
17249         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
17250 }
17251
17252 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
17253 {
17254         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17255         return NDR_ERR_SUCCESS;
17256 }
17257
17258 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
17259 {
17260         uint32_t v;
17261         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17262         *r = v;
17263         return NDR_ERR_SUCCESS;
17264 }
17265
17266 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
17267 {
17268         const char *val = NULL;
17269
17270         switch (r) {
17271                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
17272                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
17273                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
17274                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
17275                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
17276                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
17277                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
17278                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
17279                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
17280                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
17281                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
17282                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
17283                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
17284         }
17285         ndr_print_enum(ndr, name, "ENUM", val, r);
17286 }
17287
17288 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
17289 {
17290         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
17291         return NDR_ERR_SUCCESS;
17292 }
17293
17294 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
17295 {
17296         uint32_t v;
17297         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
17298         *r = v;
17299         return NDR_ERR_SUCCESS;
17300 }
17301
17302 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
17303 {
17304         const char *val = NULL;
17305
17306         switch (r) {
17307                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
17308                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
17309                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
17310         }
17311         ndr_print_enum(ndr, name, "ENUM", val, r);
17312 }
17313
17314 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
17315 {
17316         if (ndr_flags & NDR_SCALARS) {
17317                 NDR_CHECK(ndr_push_align(ndr, 5));
17318                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
17319                 {
17320                         uint32_t _flags_save_string = ndr->flags;
17321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17322                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
17323                         ndr->flags = _flags_save_string;
17324                 }
17325                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
17326                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17327         }
17328         if (ndr_flags & NDR_BUFFERS) {
17329                 {
17330                         uint32_t _flags_save_string = ndr->flags;
17331                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17332                         if (r->status_string) {
17333                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
17334                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
17335                         }
17336                         ndr->flags = _flags_save_string;
17337                 }
17338         }
17339         return NDR_ERR_SUCCESS;
17340 }
17341
17342 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
17343 {
17344         uint32_t _ptr_status_string;
17345         TALLOC_CTX *_mem_save_status_string_0;
17346         if (ndr_flags & NDR_SCALARS) {
17347                 NDR_CHECK(ndr_pull_align(ndr, 5));
17348                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
17349                 {
17350                         uint32_t _flags_save_string = ndr->flags;
17351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17352                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
17353                         if (_ptr_status_string) {
17354                                 NDR_PULL_ALLOC(ndr, r->status_string);
17355                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
17356                         } else {
17357                                 r->status_string = NULL;
17358                         }
17359                         ndr->flags = _flags_save_string;
17360                 }
17361                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
17362                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17363         }
17364         if (ndr_flags & NDR_BUFFERS) {
17365                 {
17366                         uint32_t _flags_save_string = ndr->flags;
17367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17368                         if (r->status_string) {
17369                                 uint32_t _relative_save_offset;
17370                                 _relative_save_offset = ndr->offset;
17371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
17372                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17373                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
17374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
17375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
17376                                 if (ndr->offset > ndr->relative_highest_offset) {
17377                                         ndr->relative_highest_offset = ndr->offset;
17378                                 }
17379                                 ndr->offset = _relative_save_offset;
17380                         }
17381                         ndr->flags = _flags_save_string;
17382                 }
17383         }
17384         return NDR_ERR_SUCCESS;
17385 }
17386
17387 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
17388 {
17389         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
17390         ndr->depth++;
17391         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
17392         ndr_print_ptr(ndr, "status_string", r->status_string);
17393         ndr->depth++;
17394         if (r->status_string) {
17395                 ndr_print_string(ndr, "status_string", r->status_string);
17396         }
17397         ndr->depth--;
17398         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
17399         ndr->depth--;
17400 }
17401
17402 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
17403 {
17404         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
17405 }
17406
17407 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
17408 {
17409         if (ndr_flags & NDR_SCALARS) {
17410                 NDR_CHECK(ndr_push_align(ndr, 5));
17411                 {
17412                         uint32_t _flags_save_string = ndr->flags;
17413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17414                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
17415                         ndr->flags = _flags_save_string;
17416                 }
17417                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
17418                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17419         }
17420         if (ndr_flags & NDR_BUFFERS) {
17421                 {
17422                         uint32_t _flags_save_string = ndr->flags;
17423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17424                         if (r->port_name) {
17425                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
17426                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
17427                         }
17428                         ndr->flags = _flags_save_string;
17429                 }
17430         }
17431         return NDR_ERR_SUCCESS;
17432 }
17433
17434 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
17435 {
17436         uint32_t _ptr_port_name;
17437         TALLOC_CTX *_mem_save_port_name_0;
17438         if (ndr_flags & NDR_SCALARS) {
17439                 NDR_CHECK(ndr_pull_align(ndr, 5));
17440                 {
17441                         uint32_t _flags_save_string = ndr->flags;
17442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17443                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
17444                         if (_ptr_port_name) {
17445                                 NDR_PULL_ALLOC(ndr, r->port_name);
17446                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
17447                         } else {
17448                                 r->port_name = NULL;
17449                         }
17450                         ndr->flags = _flags_save_string;
17451                 }
17452                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
17453                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17454         }
17455         if (ndr_flags & NDR_BUFFERS) {
17456                 {
17457                         uint32_t _flags_save_string = ndr->flags;
17458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17459                         if (r->port_name) {
17460                                 uint32_t _relative_save_offset;
17461                                 _relative_save_offset = ndr->offset;
17462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
17463                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17464                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
17465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
17466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
17467                                 if (ndr->offset > ndr->relative_highest_offset) {
17468                                         ndr->relative_highest_offset = ndr->offset;
17469                                 }
17470                                 ndr->offset = _relative_save_offset;
17471                         }
17472                         ndr->flags = _flags_save_string;
17473                 }
17474         }
17475         return NDR_ERR_SUCCESS;
17476 }
17477
17478 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
17479 {
17480         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
17481         ndr->depth++;
17482         ndr_print_ptr(ndr, "port_name", r->port_name);
17483         ndr->depth++;
17484         if (r->port_name) {
17485                 ndr_print_string(ndr, "port_name", r->port_name);
17486         }
17487         ndr->depth--;
17488         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
17489         ndr->depth--;
17490 }
17491
17492 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
17493 {
17494         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
17495 }
17496
17497 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
17498 {
17499         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17500         if (ndr_flags & NDR_SCALARS) {
17501                 int level = ndr_push_get_switch_value(ndr, r);
17502                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17503                 switch (level) {
17504                         case 1: {
17505                                 NDR_CHECK(ndr_push_align(ndr, 5));
17506                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17507                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17508                         break; }
17509
17510                         case 2: {
17511                                 NDR_CHECK(ndr_push_align(ndr, 5));
17512                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17513                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17514                         break; }
17515
17516                         case 3: {
17517                                 NDR_CHECK(ndr_push_align(ndr, 5));
17518                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17519                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17520                         break; }
17521
17522                         case 0xff: {
17523                                 NDR_CHECK(ndr_push_align(ndr, 5));
17524                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17525                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17526                         break; }
17527
17528                         default: {
17529                         break; }
17530
17531                 }
17532         }
17533         if (ndr_flags & NDR_BUFFERS) {
17534                 int level = ndr_push_get_switch_value(ndr, r);
17535                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17536                 switch (level) {
17537                         case 1:
17538                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17539                         break;
17540
17541                         case 2:
17542                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17543                         break;
17544
17545                         case 3:
17546                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17547                         break;
17548
17549                         case 0xff:
17550                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17551                         break;
17552
17553                         default:
17554                         break;
17555
17556                 }
17557         }
17558         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17559         return NDR_ERR_SUCCESS;
17560 }
17561
17562 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
17563 {
17564         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17565         int level;
17566         level = ndr_pull_get_switch_value(ndr, r);
17567         if (ndr_flags & NDR_SCALARS) {
17568                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17569                 switch (level) {
17570                         case 1: {
17571                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17572                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17573                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
17574                         break; }
17575
17576                         case 2: {
17577                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17578                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17579                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
17580                         break; }
17581
17582                         case 3: {
17583                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17584                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17585                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
17586                         break; }
17587
17588                         case 0xff: {
17589                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17590                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17591                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
17592                         break; }
17593
17594                         default: {
17595                         break; }
17596
17597                 }
17598         }
17599         if (ndr_flags & NDR_BUFFERS) {
17600                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
17601                 switch (level) {
17602                         case 1:
17603                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
17604                         break;
17605
17606                         case 2:
17607                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
17608                         break;
17609
17610                         case 3:
17611                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
17612                         break;
17613
17614                         case 0xff:
17615                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
17616                         break;
17617
17618                         default:
17619                         break;
17620
17621                 }
17622         }
17623         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
17624         return NDR_ERR_SUCCESS;
17625 }
17626
17627 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
17628 {
17629         int level;
17630         level = ndr_print_get_switch_value(ndr, r);
17631         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
17632         switch (level) {
17633                 case 1:
17634                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
17635                 break;
17636
17637                 case 2:
17638                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
17639                 break;
17640
17641                 case 3:
17642                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
17643                 break;
17644
17645                 case 0xff:
17646                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
17647                 break;
17648
17649                 default:
17650                 break;
17651
17652         }
17653 }
17654
17655 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
17656 {
17657         if (ndr_flags & NDR_SCALARS) {
17658                 NDR_CHECK(ndr_push_align(ndr, 5));
17659                 {
17660                         uint32_t _flags_save_string = ndr->flags;
17661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17663                         ndr->flags = _flags_save_string;
17664                 }
17665                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17666         }
17667         if (ndr_flags & NDR_BUFFERS) {
17668                 {
17669                         uint32_t _flags_save_string = ndr->flags;
17670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17671                         if (r->monitor_name) {
17672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17674                         }
17675                         ndr->flags = _flags_save_string;
17676                 }
17677         }
17678         return NDR_ERR_SUCCESS;
17679 }
17680
17681 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
17682 {
17683         uint32_t _ptr_monitor_name;
17684         TALLOC_CTX *_mem_save_monitor_name_0;
17685         if (ndr_flags & NDR_SCALARS) {
17686                 NDR_CHECK(ndr_pull_align(ndr, 5));
17687                 {
17688                         uint32_t _flags_save_string = ndr->flags;
17689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17690                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17691                         if (_ptr_monitor_name) {
17692                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17693                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17694                         } else {
17695                                 r->monitor_name = NULL;
17696                         }
17697                         ndr->flags = _flags_save_string;
17698                 }
17699                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17700         }
17701         if (ndr_flags & NDR_BUFFERS) {
17702                 {
17703                         uint32_t _flags_save_string = ndr->flags;
17704                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17705                         if (r->monitor_name) {
17706                                 uint32_t _relative_save_offset;
17707                                 _relative_save_offset = ndr->offset;
17708                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17709                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17710                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17711                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17712                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17713                                 if (ndr->offset > ndr->relative_highest_offset) {
17714                                         ndr->relative_highest_offset = ndr->offset;
17715                                 }
17716                                 ndr->offset = _relative_save_offset;
17717                         }
17718                         ndr->flags = _flags_save_string;
17719                 }
17720         }
17721         return NDR_ERR_SUCCESS;
17722 }
17723
17724 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
17725 {
17726         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
17727         ndr->depth++;
17728         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17729         ndr->depth++;
17730         if (r->monitor_name) {
17731                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17732         }
17733         ndr->depth--;
17734         ndr->depth--;
17735 }
17736
17737 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
17738 {
17739         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
17740 }
17741
17742 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
17743 {
17744         if (ndr_flags & NDR_SCALARS) {
17745                 NDR_CHECK(ndr_push_align(ndr, 5));
17746                 {
17747                         uint32_t _flags_save_string = ndr->flags;
17748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
17750                         ndr->flags = _flags_save_string;
17751                 }
17752                 {
17753                         uint32_t _flags_save_string = ndr->flags;
17754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17755                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
17756                         ndr->flags = _flags_save_string;
17757                 }
17758                 {
17759                         uint32_t _flags_save_string = ndr->flags;
17760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17761                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
17762                         ndr->flags = _flags_save_string;
17763                 }
17764                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
17765         }
17766         if (ndr_flags & NDR_BUFFERS) {
17767                 {
17768                         uint32_t _flags_save_string = ndr->flags;
17769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17770                         if (r->monitor_name) {
17771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
17772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
17773                         }
17774                         ndr->flags = _flags_save_string;
17775                 }
17776                 {
17777                         uint32_t _flags_save_string = ndr->flags;
17778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17779                         if (r->environment) {
17780                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
17781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
17782                         }
17783                         ndr->flags = _flags_save_string;
17784                 }
17785                 {
17786                         uint32_t _flags_save_string = ndr->flags;
17787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17788                         if (r->dll_name) {
17789                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
17790                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
17791                         }
17792                         ndr->flags = _flags_save_string;
17793                 }
17794         }
17795         return NDR_ERR_SUCCESS;
17796 }
17797
17798 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
17799 {
17800         uint32_t _ptr_monitor_name;
17801         TALLOC_CTX *_mem_save_monitor_name_0;
17802         uint32_t _ptr_environment;
17803         TALLOC_CTX *_mem_save_environment_0;
17804         uint32_t _ptr_dll_name;
17805         TALLOC_CTX *_mem_save_dll_name_0;
17806         if (ndr_flags & NDR_SCALARS) {
17807                 NDR_CHECK(ndr_pull_align(ndr, 5));
17808                 {
17809                         uint32_t _flags_save_string = ndr->flags;
17810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
17812                         if (_ptr_monitor_name) {
17813                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
17814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
17815                         } else {
17816                                 r->monitor_name = NULL;
17817                         }
17818                         ndr->flags = _flags_save_string;
17819                 }
17820                 {
17821                         uint32_t _flags_save_string = ndr->flags;
17822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
17824                         if (_ptr_environment) {
17825                                 NDR_PULL_ALLOC(ndr, r->environment);
17826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
17827                         } else {
17828                                 r->environment = NULL;
17829                         }
17830                         ndr->flags = _flags_save_string;
17831                 }
17832                 {
17833                         uint32_t _flags_save_string = ndr->flags;
17834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17835                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
17836                         if (_ptr_dll_name) {
17837                                 NDR_PULL_ALLOC(ndr, r->dll_name);
17838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
17839                         } else {
17840                                 r->dll_name = NULL;
17841                         }
17842                         ndr->flags = _flags_save_string;
17843                 }
17844                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
17845         }
17846         if (ndr_flags & NDR_BUFFERS) {
17847                 {
17848                         uint32_t _flags_save_string = ndr->flags;
17849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17850                         if (r->monitor_name) {
17851                                 uint32_t _relative_save_offset;
17852                                 _relative_save_offset = ndr->offset;
17853                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
17854                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17855                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
17856                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
17857                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
17858                                 if (ndr->offset > ndr->relative_highest_offset) {
17859                                         ndr->relative_highest_offset = ndr->offset;
17860                                 }
17861                                 ndr->offset = _relative_save_offset;
17862                         }
17863                         ndr->flags = _flags_save_string;
17864                 }
17865                 {
17866                         uint32_t _flags_save_string = ndr->flags;
17867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17868                         if (r->environment) {
17869                                 uint32_t _relative_save_offset;
17870                                 _relative_save_offset = ndr->offset;
17871                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
17872                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
17873                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
17874                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
17875                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
17876                                 if (ndr->offset > ndr->relative_highest_offset) {
17877                                         ndr->relative_highest_offset = ndr->offset;
17878                                 }
17879                                 ndr->offset = _relative_save_offset;
17880                         }
17881                         ndr->flags = _flags_save_string;
17882                 }
17883                 {
17884                         uint32_t _flags_save_string = ndr->flags;
17885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
17886                         if (r->dll_name) {
17887                                 uint32_t _relative_save_offset;
17888                                 _relative_save_offset = ndr->offset;
17889                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
17890                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
17891                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
17892                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
17893                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
17894                                 if (ndr->offset > ndr->relative_highest_offset) {
17895                                         ndr->relative_highest_offset = ndr->offset;
17896                                 }
17897                                 ndr->offset = _relative_save_offset;
17898                         }
17899                         ndr->flags = _flags_save_string;
17900                 }
17901         }
17902         return NDR_ERR_SUCCESS;
17903 }
17904
17905 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
17906 {
17907         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
17908         ndr->depth++;
17909         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
17910         ndr->depth++;
17911         if (r->monitor_name) {
17912                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
17913         }
17914         ndr->depth--;
17915         ndr_print_ptr(ndr, "environment", r->environment);
17916         ndr->depth++;
17917         if (r->environment) {
17918                 ndr_print_string(ndr, "environment", r->environment);
17919         }
17920         ndr->depth--;
17921         ndr_print_ptr(ndr, "dll_name", r->dll_name);
17922         ndr->depth++;
17923         if (r->dll_name) {
17924                 ndr_print_string(ndr, "dll_name", r->dll_name);
17925         }
17926         ndr->depth--;
17927         ndr->depth--;
17928 }
17929
17930 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
17931 {
17932         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
17933 }
17934
17935 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
17936 {
17937         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
17938         if (ndr_flags & NDR_SCALARS) {
17939                 int level = ndr_push_get_switch_value(ndr, r);
17940                 NDR_CHECK(ndr_push_union_align(ndr, 5));
17941                 switch (level) {
17942                         case 1: {
17943                                 NDR_CHECK(ndr_push_align(ndr, 5));
17944                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17945                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17946                         break; }
17947
17948                         case 2: {
17949                                 NDR_CHECK(ndr_push_align(ndr, 5));
17950                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
17951                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17952                         break; }
17953
17954                         default: {
17955                         break; }
17956
17957                 }
17958         }
17959         if (ndr_flags & NDR_BUFFERS) {
17960                 int level = ndr_push_get_switch_value(ndr, r);
17961                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
17962                 switch (level) {
17963                         case 1:
17964                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
17965                         break;
17966
17967                         case 2:
17968                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
17969                         break;
17970
17971                         default:
17972                         break;
17973
17974                 }
17975         }
17976         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
17977         return NDR_ERR_SUCCESS;
17978 }
17979
17980 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
17981 {
17982         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
17983         int level;
17984         level = ndr_pull_get_switch_value(ndr, r);
17985         if (ndr_flags & NDR_SCALARS) {
17986                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
17987                 switch (level) {
17988                         case 1: {
17989                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17990                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17991                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
17992                         break; }
17993
17994                         case 2: {
17995                                 NDR_CHECK(ndr_pull_align(ndr, 5));
17996                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
17997                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
17998                         break; }
17999
18000                         default: {
18001                         break; }
18002
18003                 }
18004         }
18005         if (ndr_flags & NDR_BUFFERS) {
18006                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18007                 switch (level) {
18008                         case 1:
18009                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
18010                         break;
18011
18012                         case 2:
18013                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
18014                         break;
18015
18016                         default:
18017                         break;
18018
18019                 }
18020         }
18021         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18022         return NDR_ERR_SUCCESS;
18023 }
18024
18025 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
18026 {
18027         int level;
18028         level = ndr_print_get_switch_value(ndr, r);
18029         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
18030         switch (level) {
18031                 case 1:
18032                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
18033                 break;
18034
18035                 case 2:
18036                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
18037                 break;
18038
18039                 default:
18040                 break;
18041
18042         }
18043 }
18044
18045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
18046 {
18047         if (ndr_flags & NDR_SCALARS) {
18048                 NDR_CHECK(ndr_push_align(ndr, 5));
18049                 {
18050                         uint32_t _flags_save_string = ndr->flags;
18051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18052                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
18053                         ndr->flags = _flags_save_string;
18054                 }
18055                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18056         }
18057         if (ndr_flags & NDR_BUFFERS) {
18058                 {
18059                         uint32_t _flags_save_string = ndr->flags;
18060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18061                         if (r->name_array) {
18062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
18063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
18064                         }
18065                         ndr->flags = _flags_save_string;
18066                 }
18067         }
18068         return NDR_ERR_SUCCESS;
18069 }
18070
18071 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
18072 {
18073         uint32_t _ptr_name_array;
18074         TALLOC_CTX *_mem_save_name_array_0;
18075         if (ndr_flags & NDR_SCALARS) {
18076                 NDR_CHECK(ndr_pull_align(ndr, 5));
18077                 {
18078                         uint32_t _flags_save_string = ndr->flags;
18079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18080                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
18081                         if (_ptr_name_array) {
18082                                 NDR_PULL_ALLOC(ndr, r->name_array);
18083                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
18084                         } else {
18085                                 r->name_array = NULL;
18086                         }
18087                         ndr->flags = _flags_save_string;
18088                 }
18089                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18090         }
18091         if (ndr_flags & NDR_BUFFERS) {
18092                 {
18093                         uint32_t _flags_save_string = ndr->flags;
18094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18095                         if (r->name_array) {
18096                                 uint32_t _relative_save_offset;
18097                                 _relative_save_offset = ndr->offset;
18098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
18099                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
18100                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
18101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
18102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
18103                                 if (ndr->offset > ndr->relative_highest_offset) {
18104                                         ndr->relative_highest_offset = ndr->offset;
18105                                 }
18106                                 ndr->offset = _relative_save_offset;
18107                         }
18108                         ndr->flags = _flags_save_string;
18109                 }
18110         }
18111         return NDR_ERR_SUCCESS;
18112 }
18113
18114 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
18115 {
18116         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
18117         ndr->depth++;
18118         ndr_print_ptr(ndr, "name_array", r->name_array);
18119         ndr->depth++;
18120         if (r->name_array) {
18121                 ndr_print_string(ndr, "name_array", r->name_array);
18122         }
18123         ndr->depth--;
18124         ndr->depth--;
18125 }
18126
18127 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
18128 {
18129         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
18130 }
18131
18132 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
18133 {
18134         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18135         if (ndr_flags & NDR_SCALARS) {
18136                 int level = ndr_push_get_switch_value(ndr, r);
18137                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18138                 switch (level) {
18139                         case 1: {
18140                                 NDR_CHECK(ndr_push_align(ndr, 5));
18141                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18142                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18143                         break; }
18144
18145                         default: {
18146                         break; }
18147
18148                 }
18149         }
18150         if (ndr_flags & NDR_BUFFERS) {
18151                 int level = ndr_push_get_switch_value(ndr, r);
18152                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18153                 switch (level) {
18154                         case 1:
18155                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18156                         break;
18157
18158                         default:
18159                         break;
18160
18161                 }
18162         }
18163         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18164         return NDR_ERR_SUCCESS;
18165 }
18166
18167 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
18168 {
18169         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18170         int level;
18171         level = ndr_pull_get_switch_value(ndr, r);
18172         if (ndr_flags & NDR_SCALARS) {
18173                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18174                 switch (level) {
18175                         case 1: {
18176                                 NDR_CHECK(ndr_pull_align(ndr, 5));
18177                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18178                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
18179                         break; }
18180
18181                         default: {
18182                         break; }
18183
18184                 }
18185         }
18186         if (ndr_flags & NDR_BUFFERS) {
18187                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18188                 switch (level) {
18189                         case 1:
18190                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
18191                         break;
18192
18193                         default:
18194                         break;
18195
18196                 }
18197         }
18198         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18199         return NDR_ERR_SUCCESS;
18200 }
18201
18202 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
18203 {
18204         int level;
18205         level = ndr_print_get_switch_value(ndr, r);
18206         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
18207         switch (level) {
18208                 case 1:
18209                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
18210                 break;
18211
18212                 default:
18213                 break;
18214
18215         }
18216 }
18217
18218 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18219 {
18220         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18221         return NDR_ERR_SUCCESS;
18222 }
18223
18224 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18225 {
18226         uint32_t v;
18227         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18228         *r = v;
18229         return NDR_ERR_SUCCESS;
18230 }
18231
18232 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18233 {
18234         ndr_print_uint32(ndr, name, r);
18235         ndr->depth++;
18236         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
18237         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
18238         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
18239         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
18240         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
18241         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
18242         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
18243         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
18244         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
18245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
18246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
18247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
18248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
18249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
18250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
18251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
18252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
18253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
18254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
18255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
18256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
18257         ndr->depth--;
18258 }
18259
18260 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
18261 {
18262         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18263         return NDR_ERR_SUCCESS;
18264 }
18265
18266 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
18267 {
18268         uint16_t v;
18269         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18270         *r = v;
18271         return NDR_ERR_SUCCESS;
18272 }
18273
18274 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
18275 {
18276         const char *val = NULL;
18277
18278         switch (r) {
18279                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
18280                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
18281                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
18282                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
18283                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
18284                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
18285                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18286                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
18287                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
18288                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
18289                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
18290                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
18291                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18292                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
18293                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
18294                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
18295                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
18296                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
18297                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
18298                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
18299                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
18300                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
18301                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
18302                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
18303         }
18304         ndr_print_enum(ndr, name, "ENUM", val, r);
18305 }
18306
18307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
18308 {
18309         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18310         return NDR_ERR_SUCCESS;
18311 }
18312
18313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
18314 {
18315         uint16_t v;
18316         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18317         *r = v;
18318         return NDR_ERR_SUCCESS;
18319 }
18320
18321 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
18322 {
18323         const char *val = NULL;
18324
18325         switch (r) {
18326                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
18327                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
18328                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
18329                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
18330                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
18331                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
18332                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
18333                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
18334                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
18335                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
18336                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
18337                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
18338                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
18339                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
18340                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
18341                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
18342                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
18343                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
18344                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
18345                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
18346                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
18347                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
18348                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
18349                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
18350                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
18351                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
18352                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
18353                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
18354         }
18355         ndr_print_enum(ndr, name, "ENUM", val, r);
18356 }
18357
18358 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
18359 {
18360         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
18361         return NDR_ERR_SUCCESS;
18362 }
18363
18364 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
18365 {
18366         uint16_t v;
18367         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
18368         *r = v;
18369         return NDR_ERR_SUCCESS;
18370 }
18371
18372 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
18373 {
18374         const char *val = NULL;
18375
18376         switch (r) {
18377                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
18378                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
18379         }
18380         ndr_print_enum(ndr, name, "ENUM", val, r);
18381 }
18382
18383 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
18384 {
18385         if (ndr_flags & NDR_SCALARS) {
18386                 int level = ndr_push_get_switch_value(ndr, r);
18387                 NDR_CHECK(ndr_push_union_align(ndr, 2));
18388                 switch (level) {
18389                         case PRINTER_NOTIFY_TYPE: {
18390                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18391                         break; }
18392
18393                         case JOB_NOTIFY_TYPE: {
18394                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18395                         break; }
18396
18397                         default: {
18398                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
18399                         break; }
18400
18401                 }
18402         }
18403         if (ndr_flags & NDR_BUFFERS) {
18404                 int level = ndr_push_get_switch_value(ndr, r);
18405                 switch (level) {
18406                         case PRINTER_NOTIFY_TYPE:
18407                         break;
18408
18409                         case JOB_NOTIFY_TYPE:
18410                         break;
18411
18412                         default:
18413                         break;
18414
18415                 }
18416         }
18417         return NDR_ERR_SUCCESS;
18418 }
18419
18420 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
18421 {
18422         int level;
18423         level = ndr_pull_get_switch_value(ndr, r);
18424         if (ndr_flags & NDR_SCALARS) {
18425                 NDR_CHECK(ndr_pull_union_align(ndr, 2));
18426                 switch (level) {
18427                         case PRINTER_NOTIFY_TYPE: {
18428                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18429                         break; }
18430
18431                         case JOB_NOTIFY_TYPE: {
18432                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18433                         break; }
18434
18435                         default: {
18436                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
18437                         break; }
18438
18439                 }
18440         }
18441         if (ndr_flags & NDR_BUFFERS) {
18442                 switch (level) {
18443                         case PRINTER_NOTIFY_TYPE:
18444                         break;
18445
18446                         case JOB_NOTIFY_TYPE:
18447                         break;
18448
18449                         default:
18450                         break;
18451
18452                 }
18453         }
18454         return NDR_ERR_SUCCESS;
18455 }
18456
18457 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
18458 {
18459         uint32_t cntr_fields_1;
18460         if (ndr_flags & NDR_SCALARS) {
18461                 NDR_CHECK(ndr_push_align(ndr, 5));
18462                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18463                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
18464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
18465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
18466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18467                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
18468                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18469         }
18470         if (ndr_flags & NDR_BUFFERS) {
18471                 if (r->fields) {
18472                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18473                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18474                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18475                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18476                         }
18477                 }
18478         }
18479         return NDR_ERR_SUCCESS;
18480 }
18481
18482 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
18483 {
18484         uint32_t _ptr_fields;
18485         uint32_t cntr_fields_1;
18486         TALLOC_CTX *_mem_save_fields_0;
18487         TALLOC_CTX *_mem_save_fields_1;
18488         if (ndr_flags & NDR_SCALARS) {
18489                 NDR_CHECK(ndr_pull_align(ndr, 5));
18490                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18491                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
18492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
18493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
18494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
18496                 if (_ptr_fields) {
18497                         NDR_PULL_ALLOC(ndr, r->fields);
18498                 } else {
18499                         r->fields = NULL;
18500                 }
18501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18502         }
18503         if (ndr_flags & NDR_BUFFERS) {
18504                 if (r->fields) {
18505                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
18506                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18507                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
18508                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
18509                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
18510                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
18511                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
18512                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
18513                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
18514                         }
18515                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
18516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
18517                 }
18518                 if (r->fields) {
18519                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
18520                 }
18521         }
18522         return NDR_ERR_SUCCESS;
18523 }
18524
18525 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
18526 {
18527         uint32_t cntr_fields_1;
18528         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
18529         ndr->depth++;
18530         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18531         ndr_print_uint16(ndr, "u1", r->u1);
18532         ndr_print_uint32(ndr, "u2", r->u2);
18533         ndr_print_uint32(ndr, "u3", r->u3);
18534         ndr_print_uint32(ndr, "count", r->count);
18535         ndr_print_ptr(ndr, "fields", r->fields);
18536         ndr->depth++;
18537         if (r->fields) {
18538                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
18539                 ndr->depth++;
18540                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
18541                         char *idx_1=NULL;
18542                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
18543                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
18544                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
18545                                 free(idx_1);
18546                         }
18547                 }
18548                 ndr->depth--;
18549         }
18550         ndr->depth--;
18551         ndr->depth--;
18552 }
18553
18554 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18555 {
18556         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18557         return NDR_ERR_SUCCESS;
18558 }
18559
18560 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18561 {
18562         uint32_t v;
18563         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18564         *r = v;
18565         return NDR_ERR_SUCCESS;
18566 }
18567
18568 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18569 {
18570         ndr_print_uint32(ndr, name, r);
18571         ndr->depth++;
18572         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
18573         ndr->depth--;
18574 }
18575
18576 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
18577 {
18578         uint32_t cntr_types_1;
18579         if (ndr_flags & NDR_SCALARS) {
18580                 NDR_CHECK(ndr_push_align(ndr, 5));
18581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18582                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
18583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18584                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
18585                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18586         }
18587         if (ndr_flags & NDR_BUFFERS) {
18588                 if (r->types) {
18589                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18590                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18591                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18592                         }
18593                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18594                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18595                         }
18596                 }
18597         }
18598         return NDR_ERR_SUCCESS;
18599 }
18600
18601 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
18602 {
18603         uint32_t _ptr_types;
18604         uint32_t cntr_types_1;
18605         TALLOC_CTX *_mem_save_types_0;
18606         TALLOC_CTX *_mem_save_types_1;
18607         if (ndr_flags & NDR_SCALARS) {
18608                 NDR_CHECK(ndr_pull_align(ndr, 5));
18609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18610                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
18611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
18612                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
18613                 if (_ptr_types) {
18614                         NDR_PULL_ALLOC(ndr, r->types);
18615                 } else {
18616                         r->types = NULL;
18617                 }
18618                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18619         }
18620         if (ndr_flags & NDR_BUFFERS) {
18621                 if (r->types) {
18622                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
18623                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18624                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
18625                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
18626                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
18627                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
18628                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18629                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
18630                         }
18631                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
18632                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
18633                         }
18634                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
18635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
18636                 }
18637                 if (r->types) {
18638                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
18639                 }
18640         }
18641         return NDR_ERR_SUCCESS;
18642 }
18643
18644 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
18645 {
18646         uint32_t cntr_types_1;
18647         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
18648         ndr->depth++;
18649         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
18650         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
18651         ndr_print_uint32(ndr, "count", r->count);
18652         ndr_print_ptr(ndr, "types", r->types);
18653         ndr->depth++;
18654         if (r->types) {
18655                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
18656                 ndr->depth++;
18657                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
18658                         char *idx_1=NULL;
18659                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
18660                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
18661                                 free(idx_1);
18662                         }
18663                 }
18664                 ndr->depth--;
18665         }
18666         ndr->depth--;
18667         ndr->depth--;
18668 }
18669
18670 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
18671 {
18672         if (ndr_flags & NDR_SCALARS) {
18673                 NDR_CHECK(ndr_push_align(ndr, 5));
18674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
18676                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18677         }
18678         if (ndr_flags & NDR_BUFFERS) {
18679                 if (r->string) {
18680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size / 2));
18681                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
18682                 }
18683         }
18684         return NDR_ERR_SUCCESS;
18685 }
18686
18687 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
18688 {
18689         uint32_t _ptr_string;
18690         TALLOC_CTX *_mem_save_string_0;
18691         if (ndr_flags & NDR_SCALARS) {
18692                 NDR_CHECK(ndr_pull_align(ndr, 5));
18693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
18695                 if (_ptr_string) {
18696                         NDR_PULL_ALLOC(ndr, r->string);
18697                 } else {
18698                         r->string = NULL;
18699                 }
18700                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18701         }
18702         if (ndr_flags & NDR_BUFFERS) {
18703                 if (r->string) {
18704                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
18705                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
18706                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
18707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
18708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
18709                 }
18710                 if (r->string) {
18711                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
18712                 }
18713         }
18714         return NDR_ERR_SUCCESS;
18715 }
18716
18717 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
18718 {
18719         ndr_print_struct(ndr, name, "spoolss_NotifyString");
18720         ndr->depth++;
18721         ndr_print_uint32(ndr, "size", r->size);
18722         ndr_print_ptr(ndr, "string", r->string);
18723         ndr->depth++;
18724         if (r->string) {
18725                 ndr_print_string(ndr, "string", r->string);
18726         }
18727         ndr->depth--;
18728         ndr->depth--;
18729 }
18730
18731 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
18732 {
18733         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
18734         return NDR_ERR_SUCCESS;
18735 }
18736
18737 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
18738 {
18739         uint32_t v;
18740         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
18741         *r = v;
18742         return NDR_ERR_SUCCESS;
18743 }
18744
18745 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
18746 {
18747         const char *val = NULL;
18748
18749         switch (r) {
18750                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
18751                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
18752                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
18753                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
18754                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
18755         }
18756         ndr_print_enum(ndr, name, "ENUM", val, r);
18757 }
18758
18759 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
18760 {
18761         if (ndr_flags & NDR_SCALARS) {
18762                 int level = ndr_push_get_switch_value(ndr, r);
18763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18764                 NDR_CHECK(ndr_push_union_align(ndr, 5));
18765                 switch (level) {
18766                         case 1: {
18767                                 uint32_t cntr_integer_0;
18768                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18769                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
18770                                 }
18771                         break; }
18772
18773                         case 2: {
18774                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18775                         break; }
18776
18777                         case 3: {
18778                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18779                         break; }
18780
18781                         case 4: {
18782                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18783                         break; }
18784
18785                         case 5: {
18786                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18787                         break; }
18788
18789                         default:
18790                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18791                 }
18792         }
18793         if (ndr_flags & NDR_BUFFERS) {
18794                 int level = ndr_push_get_switch_value(ndr, r);
18795                 switch (level) {
18796                         case 1:
18797                         break;
18798
18799                         case 2:
18800                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18801                         break;
18802
18803                         case 3:
18804                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18805                         break;
18806
18807                         case 4:
18808                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18809                         break;
18810
18811                         case 5:
18812                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18813                         break;
18814
18815                         default:
18816                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18817                 }
18818         }
18819         return NDR_ERR_SUCCESS;
18820 }
18821
18822 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
18823 {
18824         int level;
18825         uint32_t _level;
18826         level = ndr_pull_get_switch_value(ndr, r);
18827         if (ndr_flags & NDR_SCALARS) {
18828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18829                 if (_level != level) {
18830                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
18831                 }
18832                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
18833                 switch (level) {
18834                         case 1: {
18835                                 uint32_t cntr_integer_0;
18836                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
18837                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
18838                                 }
18839                         break; }
18840
18841                         case 2: {
18842                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
18843                         break; }
18844
18845                         case 3: {
18846                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
18847                         break; }
18848
18849                         case 4: {
18850                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
18851                         break; }
18852
18853                         case 5: {
18854                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
18855                         break; }
18856
18857                         default:
18858                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18859                 }
18860         }
18861         if (ndr_flags & NDR_BUFFERS) {
18862                 switch (level) {
18863                         case 1:
18864                         break;
18865
18866                         case 2:
18867                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
18868                         break;
18869
18870                         case 3:
18871                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
18872                         break;
18873
18874                         case 4:
18875                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
18876                         break;
18877
18878                         case 5:
18879                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
18880                         break;
18881
18882                         default:
18883                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
18884                 }
18885         }
18886         return NDR_ERR_SUCCESS;
18887 }
18888
18889 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
18890 {
18891         int level;
18892         uint32_t cntr_integer_0;
18893         level = ndr_print_get_switch_value(ndr, r);
18894         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
18895         switch (level) {
18896                 case 1:
18897                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
18898                         ndr->depth++;
18899                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
18900                                 char *idx_0=NULL;
18901                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
18902                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
18903                                         free(idx_0);
18904                                 }
18905                         }
18906                         ndr->depth--;
18907                 break;
18908
18909                 case 2:
18910                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
18911                 break;
18912
18913                 case 3:
18914                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
18915                 break;
18916
18917                 case 4:
18918                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
18919                 break;
18920
18921                 case 5:
18922                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
18923                 break;
18924
18925                 default:
18926                         ndr_print_bad_level(ndr, name, level);
18927         }
18928 }
18929
18930 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
18931 {
18932         if (ndr_flags & NDR_SCALARS) {
18933                 NDR_CHECK(ndr_push_align(ndr, 5));
18934                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
18935                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
18936                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18937                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
18938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
18939                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
18940                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18941                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18942         }
18943         if (ndr_flags & NDR_BUFFERS) {
18944                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18945         }
18946         return NDR_ERR_SUCCESS;
18947 }
18948
18949 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
18950 {
18951         if (ndr_flags & NDR_SCALARS) {
18952                 NDR_CHECK(ndr_pull_align(ndr, 5));
18953                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
18954                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
18955                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
18956                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
18957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
18958                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
18959                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
18960                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
18961         }
18962         if (ndr_flags & NDR_BUFFERS) {
18963                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
18964         }
18965         return NDR_ERR_SUCCESS;
18966 }
18967
18968 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
18969 {
18970         ndr_print_struct(ndr, name, "spoolss_Notify");
18971         ndr->depth++;
18972         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
18973         ndr_print_set_switch_value(ndr, &r->field, r->type);
18974         ndr_print_spoolss_Field(ndr, "field", &r->field);
18975         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
18976         ndr_print_uint32(ndr, "job_id", r->job_id);
18977         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
18978         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
18979         ndr->depth--;
18980 }
18981
18982 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
18983 {
18984         uint32_t cntr_notifies_0;
18985         if (ndr_flags & NDR_SCALARS) {
18986                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
18987                 NDR_CHECK(ndr_push_align(ndr, 5));
18988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
18989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
18991                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18992                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
18993                 }
18994                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
18995         }
18996         if (ndr_flags & NDR_BUFFERS) {
18997                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
18998                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
18999                 }
19000         }
19001         return NDR_ERR_SUCCESS;
19002 }
19003
19004 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
19005 {
19006         uint32_t cntr_notifies_0;
19007         TALLOC_CTX *_mem_save_notifies_0;
19008         if (ndr_flags & NDR_SCALARS) {
19009                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
19010                 NDR_CHECK(ndr_pull_align(ndr, 5));
19011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
19012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
19014                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
19015                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19016                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19017                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19018                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
19019                 }
19020                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19021                 if (r->notifies) {
19022                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
19023                 }
19024                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19025         }
19026         if (ndr_flags & NDR_BUFFERS) {
19027                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
19028                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
19029                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
19030                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
19031                 }
19032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
19033         }
19034         return NDR_ERR_SUCCESS;
19035 }
19036
19037 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
19038 {
19039         uint32_t cntr_notifies_0;
19040         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
19041         ndr->depth++;
19042         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
19043         ndr_print_uint32(ndr, "flags", r->flags);
19044         ndr_print_uint32(ndr, "count", r->count);
19045         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
19046         ndr->depth++;
19047         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
19048                 char *idx_0=NULL;
19049                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
19050                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
19051                         free(idx_0);
19052                 }
19053         }
19054         ndr->depth--;
19055         ndr->depth--;
19056 }
19057
19058 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
19059 {
19060         if (ndr_flags & NDR_SCALARS) {
19061                 int level = ndr_push_get_switch_value(ndr, r);
19062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19063                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19064                 switch (level) {
19065                         case 0: {
19066                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
19067                         break; }
19068
19069                         default:
19070                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19071                 }
19072         }
19073         if (ndr_flags & NDR_BUFFERS) {
19074                 int level = ndr_push_get_switch_value(ndr, r);
19075                 switch (level) {
19076                         case 0:
19077                                 if (r->info0) {
19078                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19079                                 }
19080                         break;
19081
19082                         default:
19083                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19084                 }
19085         }
19086         return NDR_ERR_SUCCESS;
19087 }
19088
19089 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
19090 {
19091         int level;
19092         uint32_t _level;
19093         TALLOC_CTX *_mem_save_info0_0;
19094         level = ndr_pull_get_switch_value(ndr, r);
19095         if (ndr_flags & NDR_SCALARS) {
19096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19097                 if (_level != level) {
19098                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19099                 }
19100                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19101                 switch (level) {
19102                         case 0: {
19103                                 uint32_t _ptr_info0;
19104                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
19105                                 if (_ptr_info0) {
19106                                         NDR_PULL_ALLOC(ndr, r->info0);
19107                                 } else {
19108                                         r->info0 = NULL;
19109                                 }
19110                         break; }
19111
19112                         default:
19113                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19114                 }
19115         }
19116         if (ndr_flags & NDR_BUFFERS) {
19117                 switch (level) {
19118                         case 0:
19119                                 if (r->info0) {
19120                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
19121                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
19122                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
19123                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
19124                                 }
19125                         break;
19126
19127                         default:
19128                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19129                 }
19130         }
19131         return NDR_ERR_SUCCESS;
19132 }
19133
19134 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
19135 {
19136         int level;
19137         level = ndr_print_get_switch_value(ndr, r);
19138         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
19139         switch (level) {
19140                 case 0:
19141                         ndr_print_ptr(ndr, "info0", r->info0);
19142                         ndr->depth++;
19143                         if (r->info0) {
19144                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
19145                         }
19146                         ndr->depth--;
19147                 break;
19148
19149                 default:
19150                         ndr_print_bad_level(ndr, name, level);
19151         }
19152 }
19153
19154 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19155 {
19156         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19157         return NDR_ERR_SUCCESS;
19158 }
19159
19160 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19161 {
19162         uint32_t v;
19163         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19164         *r = v;
19165         return NDR_ERR_SUCCESS;
19166 }
19167
19168 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19169 {
19170         ndr_print_uint32(ndr, name, r);
19171         ndr->depth++;
19172         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
19173         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
19174         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
19175         ndr->depth--;
19176 }
19177
19178 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
19179 {
19180         if (ndr_flags & NDR_SCALARS) {
19181                 NDR_CHECK(ndr_push_align(ndr, 5));
19182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19186                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19187                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19188                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19189                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19190         }
19191         if (ndr_flags & NDR_BUFFERS) {
19192                 if (r->client) {
19193                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19194                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19195                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19196                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19197                 }
19198                 if (r->user) {
19199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19200                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19203                 }
19204         }
19205         return NDR_ERR_SUCCESS;
19206 }
19207
19208 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
19209 {
19210         uint32_t _ptr_client;
19211         TALLOC_CTX *_mem_save_client_0;
19212         uint32_t _ptr_user;
19213         TALLOC_CTX *_mem_save_user_0;
19214         if (ndr_flags & NDR_SCALARS) {
19215                 NDR_CHECK(ndr_pull_align(ndr, 5));
19216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19218                 if (_ptr_client) {
19219                         NDR_PULL_ALLOC(ndr, r->client);
19220                 } else {
19221                         r->client = NULL;
19222                 }
19223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19224                 if (_ptr_user) {
19225                         NDR_PULL_ALLOC(ndr, r->user);
19226                 } else {
19227                         r->user = NULL;
19228                 }
19229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19230                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19231                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19232                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19234         }
19235         if (ndr_flags & NDR_BUFFERS) {
19236                 if (r->client) {
19237                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19238                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19241                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19242                                 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));
19243                         }
19244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19245                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19247                 }
19248                 if (r->user) {
19249                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19250                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19253                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19254                                 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));
19255                         }
19256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19259                 }
19260         }
19261         return NDR_ERR_SUCCESS;
19262 }
19263
19264 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
19265 {
19266         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
19267         ndr->depth++;
19268         ndr_print_uint32(ndr, "size", r->size);
19269         ndr_print_ptr(ndr, "client", r->client);
19270         ndr->depth++;
19271         if (r->client) {
19272                 ndr_print_string(ndr, "client", r->client);
19273         }
19274         ndr->depth--;
19275         ndr_print_ptr(ndr, "user", r->user);
19276         ndr->depth++;
19277         if (r->user) {
19278                 ndr_print_string(ndr, "user", r->user);
19279         }
19280         ndr->depth--;
19281         ndr_print_uint32(ndr, "build", r->build);
19282         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19283         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19284         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19285         ndr->depth--;
19286 }
19287
19288 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
19289 {
19290         if (ndr_flags & NDR_SCALARS) {
19291                 NDR_CHECK(ndr_push_align(ndr, 4));
19292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
19293                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19294         }
19295         if (ndr_flags & NDR_BUFFERS) {
19296         }
19297         return NDR_ERR_SUCCESS;
19298 }
19299
19300 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
19301 {
19302         if (ndr_flags & NDR_SCALARS) {
19303                 NDR_CHECK(ndr_pull_align(ndr, 4));
19304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
19305                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
19306         }
19307         if (ndr_flags & NDR_BUFFERS) {
19308         }
19309         return NDR_ERR_SUCCESS;
19310 }
19311
19312 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
19313 {
19314         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
19315         ndr->depth++;
19316         ndr_print_uint32(ndr, "not_used", r->not_used);
19317         ndr->depth--;
19318 }
19319
19320 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
19321 {
19322         if (ndr_flags & NDR_SCALARS) {
19323                 NDR_CHECK(ndr_push_align(ndr, 5));
19324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
19325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
19326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
19327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
19328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
19329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
19330                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
19331                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
19332                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
19333                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
19334                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19335         }
19336         if (ndr_flags & NDR_BUFFERS) {
19337                 if (r->client) {
19338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19339                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19340                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
19341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19342                 }
19343                 if (r->user) {
19344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19345                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
19346                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
19347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19348                 }
19349         }
19350         return NDR_ERR_SUCCESS;
19351 }
19352
19353 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
19354 {
19355         uint32_t _ptr_client;
19356         TALLOC_CTX *_mem_save_client_0;
19357         uint32_t _ptr_user;
19358         TALLOC_CTX *_mem_save_user_0;
19359         if (ndr_flags & NDR_SCALARS) {
19360                 NDR_CHECK(ndr_pull_align(ndr, 5));
19361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
19362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
19363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
19364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
19365                 if (_ptr_client) {
19366                         NDR_PULL_ALLOC(ndr, r->client);
19367                 } else {
19368                         r->client = NULL;
19369                 }
19370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
19371                 if (_ptr_user) {
19372                         NDR_PULL_ALLOC(ndr, r->user);
19373                 } else {
19374                         r->user = NULL;
19375                 }
19376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
19377                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
19378                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
19379                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
19380                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
19381                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19382         }
19383         if (ndr_flags & NDR_BUFFERS) {
19384                 if (r->client) {
19385                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
19386                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
19387                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
19388                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
19389                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
19390                                 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));
19391                         }
19392                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
19393                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
19394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
19395                 }
19396                 if (r->user) {
19397                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
19398                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
19399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
19400                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
19401                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
19402                                 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));
19403                         }
19404                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
19405                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
19406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
19407                 }
19408         }
19409         return NDR_ERR_SUCCESS;
19410 }
19411
19412 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
19413 {
19414         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
19415         ndr->depth++;
19416         ndr_print_uint32(ndr, "size", r->size);
19417         ndr_print_uint32(ndr, "flags", r->flags);
19418         ndr_print_uint32(ndr, "size2", r->size2);
19419         ndr_print_ptr(ndr, "client", r->client);
19420         ndr->depth++;
19421         if (r->client) {
19422                 ndr_print_string(ndr, "client", r->client);
19423         }
19424         ndr->depth--;
19425         ndr_print_ptr(ndr, "user", r->user);
19426         ndr->depth++;
19427         if (r->user) {
19428                 ndr_print_string(ndr, "user", r->user);
19429         }
19430         ndr->depth--;
19431         ndr_print_uint32(ndr, "build", r->build);
19432         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
19433         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
19434         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
19435         ndr_print_udlong(ndr, "reserved", r->reserved);
19436         ndr->depth--;
19437 }
19438
19439 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
19440 {
19441         if (ndr_flags & NDR_SCALARS) {
19442                 int level = ndr_push_get_switch_value(ndr, r);
19443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
19444                 NDR_CHECK(ndr_push_union_align(ndr, 5));
19445                 switch (level) {
19446                         case 1: {
19447                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
19448                         break; }
19449
19450                         case 2: {
19451                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
19452                         break; }
19453
19454                         case 3: {
19455                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
19456                         break; }
19457
19458                         default:
19459                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19460                 }
19461         }
19462         if (ndr_flags & NDR_BUFFERS) {
19463                 int level = ndr_push_get_switch_value(ndr, r);
19464                 switch (level) {
19465                         case 1:
19466                                 if (r->level1) {
19467                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19468                                 }
19469                         break;
19470
19471                         case 2:
19472                                 if (r->level2) {
19473                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19474                                 }
19475                         break;
19476
19477                         case 3:
19478                                 if (r->level3) {
19479                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19480                                 }
19481                         break;
19482
19483                         default:
19484                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19485                 }
19486         }
19487         return NDR_ERR_SUCCESS;
19488 }
19489
19490 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
19491 {
19492         int level;
19493         uint32_t _level;
19494         TALLOC_CTX *_mem_save_level1_0;
19495         TALLOC_CTX *_mem_save_level2_0;
19496         TALLOC_CTX *_mem_save_level3_0;
19497         level = ndr_pull_get_switch_value(ndr, r);
19498         if (ndr_flags & NDR_SCALARS) {
19499                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
19500                 if (_level != level) {
19501                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
19502                 }
19503                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
19504                 switch (level) {
19505                         case 1: {
19506                                 uint32_t _ptr_level1;
19507                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
19508                                 if (_ptr_level1) {
19509                                         NDR_PULL_ALLOC(ndr, r->level1);
19510                                 } else {
19511                                         r->level1 = NULL;
19512                                 }
19513                         break; }
19514
19515                         case 2: {
19516                                 uint32_t _ptr_level2;
19517                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
19518                                 if (_ptr_level2) {
19519                                         NDR_PULL_ALLOC(ndr, r->level2);
19520                                 } else {
19521                                         r->level2 = NULL;
19522                                 }
19523                         break; }
19524
19525                         case 3: {
19526                                 uint32_t _ptr_level3;
19527                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
19528                                 if (_ptr_level3) {
19529                                         NDR_PULL_ALLOC(ndr, r->level3);
19530                                 } else {
19531                                         r->level3 = NULL;
19532                                 }
19533                         break; }
19534
19535                         default:
19536                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19537                 }
19538         }
19539         if (ndr_flags & NDR_BUFFERS) {
19540                 switch (level) {
19541                         case 1:
19542                                 if (r->level1) {
19543                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
19544                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
19545                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
19546                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
19547                                 }
19548                         break;
19549
19550                         case 2:
19551                                 if (r->level2) {
19552                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
19553                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
19554                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
19555                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
19556                                 }
19557                         break;
19558
19559                         case 3:
19560                                 if (r->level3) {
19561                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
19562                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
19563                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
19564                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
19565                                 }
19566                         break;
19567
19568                         default:
19569                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
19570                 }
19571         }
19572         return NDR_ERR_SUCCESS;
19573 }
19574
19575 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
19576 {
19577         int level;
19578         level = ndr_print_get_switch_value(ndr, r);
19579         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
19580         switch (level) {
19581                 case 1:
19582                         ndr_print_ptr(ndr, "level1", r->level1);
19583                         ndr->depth++;
19584                         if (r->level1) {
19585                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
19586                         }
19587                         ndr->depth--;
19588                 break;
19589
19590                 case 2:
19591                         ndr_print_ptr(ndr, "level2", r->level2);
19592                         ndr->depth++;
19593                         if (r->level2) {
19594                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
19595                         }
19596                         ndr->depth--;
19597                 break;
19598
19599                 case 3:
19600                         ndr_print_ptr(ndr, "level3", r->level3);
19601                         ndr->depth++;
19602                         if (r->level3) {
19603                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
19604                         }
19605                         ndr->depth--;
19606                 break;
19607
19608                 default:
19609                         ndr_print_bad_level(ndr, name, level);
19610         }
19611 }
19612
19613 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
19614 {
19615         if (ndr_flags & NDR_SCALARS) {
19616                 NDR_CHECK(ndr_push_align(ndr, 5));
19617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
19618                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
19619                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19620                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19621         }
19622         if (ndr_flags & NDR_BUFFERS) {
19623                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19624         }
19625         return NDR_ERR_SUCCESS;
19626 }
19627
19628 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
19629 {
19630         if (ndr_flags & NDR_SCALARS) {
19631                 NDR_CHECK(ndr_pull_align(ndr, 5));
19632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
19633                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
19634                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
19635                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19636         }
19637         if (ndr_flags & NDR_BUFFERS) {
19638                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
19639         }
19640         return NDR_ERR_SUCCESS;
19641 }
19642
19643 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
19644 {
19645         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
19646         ndr->depth++;
19647         ndr_print_uint32(ndr, "level", r->level);
19648         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
19649         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
19650         ndr->depth--;
19651 }
19652
19653 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19654 {
19655         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19656         return NDR_ERR_SUCCESS;
19657 }
19658
19659 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19660 {
19661         uint32_t v;
19662         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19663         *r = v;
19664         return NDR_ERR_SUCCESS;
19665 }
19666
19667 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
19668 {
19669         ndr_print_uint32(ndr, name, r);
19670         ndr->depth++;
19671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
19672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
19673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
19674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
19675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
19676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
19677         ndr->depth--;
19678 }
19679
19680 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
19681 {
19682         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
19683         if (ndr_flags & NDR_SCALARS) {
19684                 NDR_CHECK(ndr_push_align(ndr, 5));
19685                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
19686                 {
19687                         uint32_t _flags_save_string = ndr->flags;
19688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19689                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
19690                         ndr->flags = _flags_save_string;
19691                 }
19692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
19693                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
19694                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
19695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
19696                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
19697         }
19698         if (ndr_flags & NDR_BUFFERS) {
19699                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
19700                 {
19701                         uint32_t _flags_save_string = ndr->flags;
19702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19703                         if (r->value_name) {
19704                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
19705                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
19706                         }
19707                         ndr->flags = _flags_save_string;
19708                 }
19709                 if (r->data) {
19710                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
19711                         {
19712                                 struct ndr_push *_ndr_data;
19713                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19714                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
19715                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19716                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19717                         }
19718                 }
19719         }
19720         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
19721         return NDR_ERR_SUCCESS;
19722 }
19723
19724 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
19725 {
19726         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
19727         uint32_t _ptr_value_name;
19728         TALLOC_CTX *_mem_save_value_name_0;
19729         uint32_t _ptr_data;
19730         TALLOC_CTX *_mem_save_data_0;
19731         if (ndr_flags & NDR_SCALARS) {
19732                 NDR_CHECK(ndr_pull_align(ndr, 5));
19733                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
19734                 {
19735                         uint32_t _flags_save_string = ndr->flags;
19736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19737                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
19738                         if (_ptr_value_name) {
19739                                 NDR_PULL_ALLOC(ndr, r->value_name);
19740                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
19741                         } else {
19742                                 r->value_name = NULL;
19743                         }
19744                         ndr->flags = _flags_save_string;
19745                 }
19746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
19747                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
19748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
19749                 if (_ptr_data) {
19750                         NDR_PULL_ALLOC(ndr, r->data);
19751                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
19752                 } else {
19753                         r->data = NULL;
19754                 }
19755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
19756                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
19757         }
19758         if (ndr_flags & NDR_BUFFERS) {
19759                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
19760                 {
19761                         uint32_t _flags_save_string = ndr->flags;
19762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19763                         if (r->value_name) {
19764                                 uint32_t _relative_save_offset;
19765                                 _relative_save_offset = ndr->offset;
19766                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
19767                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
19768                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
19769                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
19770                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
19771                                 if (ndr->offset > ndr->relative_highest_offset) {
19772                                         ndr->relative_highest_offset = ndr->offset;
19773                                 }
19774                                 ndr->offset = _relative_save_offset;
19775                         }
19776                         ndr->flags = _flags_save_string;
19777                 }
19778                 if (r->data) {
19779                         uint32_t _relative_save_offset;
19780                         _relative_save_offset = ndr->offset;
19781                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
19782                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
19783                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
19784                         {
19785                                 struct ndr_pull *_ndr_data;
19786                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
19787                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
19788                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
19789                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
19790                         }
19791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
19792                         if (ndr->offset > ndr->relative_highest_offset) {
19793                                 ndr->relative_highest_offset = ndr->offset;
19794                         }
19795                         ndr->offset = _relative_save_offset;
19796                 }
19797         }
19798         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
19799         return NDR_ERR_SUCCESS;
19800 }
19801
19802 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
19803 {
19804         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
19805         ndr->depth++;
19806         ndr_print_ptr(ndr, "value_name", r->value_name);
19807         ndr->depth++;
19808         if (r->value_name) {
19809                 ndr_print_string(ndr, "value_name", r->value_name);
19810         }
19811         ndr->depth--;
19812         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
19813         ndr_print_winreg_Type(ndr, "type", r->type);
19814         ndr_print_ptr(ndr, "data", r->data);
19815         ndr->depth++;
19816         if (r->data) {
19817                 ndr_print_set_switch_value(ndr, r->data, r->type);
19818                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
19819         }
19820         ndr->depth--;
19821         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);
19822         ndr->depth--;
19823 }
19824
19825 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
19826 {
19827         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
19828 }
19829
19830 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
19831 {
19832         if (ndr_flags & NDR_SCALARS) {
19833                 int level = ndr_push_get_switch_value(ndr, r);
19834                 NDR_CHECK(ndr_push_union_align(ndr, 4));
19835                 switch (level) {
19836                         case 0: {
19837                         break; }
19838
19839                         case 1: {
19840                         break; }
19841
19842                         default: {
19843                                 {
19844                                         uint32_t _flags_save_string_array = ndr->flags;
19845                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19846                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
19847                                         ndr->flags = _flags_save_string_array;
19848                                 }
19849                         break; }
19850
19851                 }
19852         }
19853         if (ndr_flags & NDR_BUFFERS) {
19854                 int level = ndr_push_get_switch_value(ndr, r);
19855                 switch (level) {
19856                         case 0:
19857                         break;
19858
19859                         case 1:
19860                         break;
19861
19862                         default:
19863                         break;
19864
19865                 }
19866         }
19867         return NDR_ERR_SUCCESS;
19868 }
19869
19870 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
19871 {
19872         int level;
19873         level = ndr_pull_get_switch_value(ndr, r);
19874         if (ndr_flags & NDR_SCALARS) {
19875                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
19876                 switch (level) {
19877                         case 0: {
19878                         break; }
19879
19880                         case 1: {
19881                         break; }
19882
19883                         default: {
19884                                 {
19885                                         uint32_t _flags_save_string_array = ndr->flags;
19886                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
19887                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
19888                                         ndr->flags = _flags_save_string_array;
19889                                 }
19890                         break; }
19891
19892                 }
19893         }
19894         if (ndr_flags & NDR_BUFFERS) {
19895                 switch (level) {
19896                         case 0:
19897                         break;
19898
19899                         case 1:
19900                         break;
19901
19902                         default:
19903                         break;
19904
19905                 }
19906         }
19907         return NDR_ERR_SUCCESS;
19908 }
19909
19910 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
19911 {
19912         int level;
19913         level = ndr_print_get_switch_value(ndr, r);
19914         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
19915         switch (level) {
19916                 case 0:
19917                 break;
19918
19919                 case 1:
19920                 break;
19921
19922                 default:
19923                         ndr_print_string_array(ndr, "string_array", r->string_array);
19924                 break;
19925
19926         }
19927 }
19928
19929 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
19930 {
19931         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
19932         return NDR_ERR_SUCCESS;
19933 }
19934
19935 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
19936 {
19937         uint32_t v;
19938         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
19939         *r = v;
19940         return NDR_ERR_SUCCESS;
19941 }
19942
19943 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
19944 {
19945         ndr_print_uint32(ndr, name, r);
19946         ndr->depth++;
19947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
19948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
19949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
19950         ndr->depth--;
19951 }
19952
19953 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
19954 {
19955         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
19956         return NDR_ERR_SUCCESS;
19957 }
19958
19959 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
19960 {
19961         uint32_t v;
19962         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
19963         *r = v;
19964         return NDR_ERR_SUCCESS;
19965 }
19966
19967 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
19968 {
19969         const char *val = NULL;
19970
19971         switch (r) {
19972                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
19973                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
19974         }
19975         ndr_print_enum(ndr, name, "ENUM", val, r);
19976 }
19977
19978 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
19979 {
19980         if (ndr_flags & NDR_SCALARS) {
19981                 NDR_CHECK(ndr_push_align(ndr, 4));
19982                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
19983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
19984                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
19985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
19986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
19987                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
19988                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
19989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
19990                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
19991                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
19992                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
19993                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
19994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
19995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
19996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
19997                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
19998         }
19999         if (ndr_flags & NDR_BUFFERS) {
20000         }
20001         return NDR_ERR_SUCCESS;
20002 }
20003
20004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
20005 {
20006         if (ndr_flags & NDR_SCALARS) {
20007                 NDR_CHECK(ndr_pull_align(ndr, 4));
20008                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20010                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20013                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
20014                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20016                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20017                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
20018                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
20019                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20024         }
20025         if (ndr_flags & NDR_BUFFERS) {
20026         }
20027         return NDR_ERR_SUCCESS;
20028 }
20029
20030 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
20031 {
20032         ndr_print_struct(ndr, name, "spoolss_PortData1");
20033         ndr->depth++;
20034         ndr_print_string(ndr, "portname", r->portname);
20035         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
20036         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20037         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20038         ndr_print_uint32(ndr, "reserved", r->reserved);
20039         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20040         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20041         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20042         ndr_print_string(ndr, "queue", r->queue);
20043         ndr_print_string(ndr, "ip_address", r->ip_address);
20044         ndr_print_string(ndr, "hardware_address", r->hardware_address);
20045         ndr_print_string(ndr, "device_type", r->device_type);
20046         ndr_print_uint32(ndr, "port_number", r->port_number);
20047         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20048         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20049         ndr->depth--;
20050 }
20051
20052 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
20053 {
20054         if (ndr_flags & NDR_SCALARS) {
20055                 NDR_CHECK(ndr_push_align(ndr, 4));
20056                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
20057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
20058                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
20059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
20060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
20061                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20062                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
20064                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
20065                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
20067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
20068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
20069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
20070                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20071         }
20072         if (ndr_flags & NDR_BUFFERS) {
20073         }
20074         return NDR_ERR_SUCCESS;
20075 }
20076
20077 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
20078 {
20079         if (ndr_flags & NDR_SCALARS) {
20080                 NDR_CHECK(ndr_pull_align(ndr, 4));
20081                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
20082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
20083                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
20084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
20085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
20086                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
20087                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
20088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
20089                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
20090                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
20091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
20092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
20093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
20094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
20095                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20096         }
20097         if (ndr_flags & NDR_BUFFERS) {
20098         }
20099         return NDR_ERR_SUCCESS;
20100 }
20101
20102 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
20103 {
20104         ndr_print_struct(ndr, name, "spoolss_PortData2");
20105         ndr->depth++;
20106         ndr_print_string(ndr, "portname", r->portname);
20107         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
20108         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
20109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
20110         ndr_print_uint32(ndr, "reserved", r->reserved);
20111         ndr_print_string(ndr, "hostaddress", r->hostaddress);
20112         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
20113         ndr_print_uint32(ndr, "dblspool", r->dblspool);
20114         ndr_print_string(ndr, "queue", r->queue);
20115         ndr_print_string(ndr, "device_type", r->device_type);
20116         ndr_print_uint32(ndr, "port_number", r->port_number);
20117         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
20118         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
20119         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
20120         ndr->depth--;
20121 }
20122
20123 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
20124 {
20125         if (ndr_flags & NDR_SCALARS) {
20126                 NDR_CHECK(ndr_push_align(ndr, 4));
20127                 {
20128                         uint32_t _flags_save_string = ndr->flags;
20129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20130                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
20131                         ndr->flags = _flags_save_string;
20132                 }
20133                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
20134         }
20135         if (ndr_flags & NDR_BUFFERS) {
20136         }
20137         return NDR_ERR_SUCCESS;
20138 }
20139
20140 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
20141 {
20142         if (ndr_flags & NDR_SCALARS) {
20143                 NDR_CHECK(ndr_pull_align(ndr, 4));
20144                 {
20145                         uint32_t _flags_save_string = ndr->flags;
20146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
20147                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
20148                         ndr->flags = _flags_save_string;
20149                 }
20150                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
20151         }
20152         if (ndr_flags & NDR_BUFFERS) {
20153         }
20154         return NDR_ERR_SUCCESS;
20155 }
20156
20157 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
20158 {
20159         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
20160         ndr->depth++;
20161         ndr_print_string(ndr, "dll_name", r->dll_name);
20162         ndr->depth--;
20163 }
20164
20165 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
20166 {
20167         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
20168         return NDR_ERR_SUCCESS;
20169 }
20170
20171 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
20172 {
20173         uint32_t v;
20174         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
20175         *r = v;
20176         return NDR_ERR_SUCCESS;
20177 }
20178
20179 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
20180 {
20181         ndr_print_uint32(ndr, name, r);
20182         ndr->depth++;
20183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
20184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
20185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
20186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
20187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
20188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
20189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
20190         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
20191         ndr->depth--;
20192 }
20193
20194 static enum ndr_err_code ndr_push_spoolss_CorePrinterDriver(struct ndr_push *ndr, int ndr_flags, const struct spoolss_CorePrinterDriver *r)
20195 {
20196         if (ndr_flags & NDR_SCALARS) {
20197                 NDR_CHECK(ndr_push_align(ndr, 8));
20198                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20199                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
20200                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
20201                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 520, sizeof(uint8_t), CH_UTF8));
20202                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
20203         }
20204         if (ndr_flags & NDR_BUFFERS) {
20205         }
20206         return NDR_ERR_SUCCESS;
20207 }
20208
20209 static enum ndr_err_code ndr_pull_spoolss_CorePrinterDriver(struct ndr_pull *ndr, int ndr_flags, struct spoolss_CorePrinterDriver *r)
20210 {
20211         if (ndr_flags & NDR_SCALARS) {
20212                 NDR_CHECK(ndr_pull_align(ndr, 8));
20213                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->core_driver_guid));
20214                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
20215                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
20216                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 520, sizeof(uint8_t), CH_UTF8));
20217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
20218         }
20219         if (ndr_flags & NDR_BUFFERS) {
20220         }
20221         return NDR_ERR_SUCCESS;
20222 }
20223
20224 _PUBLIC_ void ndr_print_spoolss_CorePrinterDriver(struct ndr_print *ndr, const char *name, const struct spoolss_CorePrinterDriver *r)
20225 {
20226         ndr_print_struct(ndr, name, "spoolss_CorePrinterDriver");
20227         ndr->depth++;
20228         ndr_print_GUID(ndr, "core_driver_guid", &r->core_driver_guid);
20229         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
20230         ndr_print_hyper(ndr, "driver_version", r->driver_version);
20231         ndr_print_string(ndr, "formname", r->formname);
20232         ndr->depth--;
20233 }
20234
20235 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
20236 {
20237         if (flags & NDR_IN) {
20238                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
20239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20240                 if (r->in.server) {
20241                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20242                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20243                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20244                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20245                 }
20246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20247                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20248                 if (r->in.buffer) {
20249                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20250                 }
20251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20252         }
20253         if (flags & NDR_OUT) {
20254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20255                 if (r->out.info) {
20256                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20257                 }
20258                 if (r->out.needed == NULL) {
20259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20260                 }
20261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20262                 if (r->out.count == NULL) {
20263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20264                 }
20265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20267         }
20268         return NDR_ERR_SUCCESS;
20269 }
20270
20271 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
20272 {
20273         uint32_t _ptr_server;
20274         uint32_t _ptr_buffer;
20275         uint32_t _ptr_info;
20276         TALLOC_CTX *_mem_save_server_0;
20277         TALLOC_CTX *_mem_save_buffer_0;
20278         TALLOC_CTX *_mem_save_info_0;
20279         TALLOC_CTX *_mem_save_needed_0;
20280         TALLOC_CTX *_mem_save_count_0;
20281         if (flags & NDR_IN) {
20282                 ZERO_STRUCT(r->out);
20283
20284                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
20285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20286                 if (_ptr_server) {
20287                         NDR_PULL_ALLOC(ndr, r->in.server);
20288                 } else {
20289                         r->in.server = NULL;
20290                 }
20291                 if (r->in.server) {
20292                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20293                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20294                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20295                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20296                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20297                                 return 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));
20298                         }
20299                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20300                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20302                 }
20303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20305                 if (_ptr_buffer) {
20306                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20307                 } else {
20308                         r->in.buffer = NULL;
20309                 }
20310                 if (r->in.buffer) {
20311                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20312                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20313                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20314                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20315                 }
20316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20317                 NDR_PULL_ALLOC(ndr, r->out.needed);
20318                 ZERO_STRUCTP(r->out.needed);
20319                 NDR_PULL_ALLOC(ndr, r->out.count);
20320                 ZERO_STRUCTP(r->out.count);
20321         }
20322         if (flags & NDR_OUT) {
20323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20324                 if (_ptr_info) {
20325                         NDR_PULL_ALLOC(ndr, r->out.info);
20326                 } else {
20327                         r->out.info = NULL;
20328                 }
20329                 if (r->out.info) {
20330                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20331                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20332                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20334                 }
20335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20336                         NDR_PULL_ALLOC(ndr, r->out.needed);
20337                 }
20338                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20339                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20343                         NDR_PULL_ALLOC(ndr, r->out.count);
20344                 }
20345                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20346                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20349                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20350         }
20351         return NDR_ERR_SUCCESS;
20352 }
20353
20354 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
20355 {
20356         uint32_t cntr_info_0;
20357         if (flags & NDR_IN) {
20358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20360         }
20361         if (flags & NDR_OUT) {
20362                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20363                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20364                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20365                 }
20366                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20367                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20368                 }
20369         }
20370         return NDR_ERR_SUCCESS;
20371 }
20372
20373 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
20374 {
20375         uint32_t cntr_info_0;
20376         TALLOC_CTX *_mem_save_info_0;
20377         if (flags & NDR_IN) {
20378                 ZERO_STRUCT(r->out);
20379
20380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20382         }
20383         if (flags & NDR_OUT) {
20384                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20385                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20386                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20387                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20388                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20389                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20390                 }
20391                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20392                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20393                 }
20394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20395         }
20396         return NDR_ERR_SUCCESS;
20397 }
20398
20399 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
20400 {
20401         uint32_t cntr_info_2;
20402         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
20403         ndr->depth++;
20404         if (flags & NDR_SET_VALUES) {
20405                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20406         }
20407         if (flags & NDR_IN) {
20408                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
20409                 ndr->depth++;
20410                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
20411                 ndr_print_ptr(ndr, "server", r->in.server);
20412                 ndr->depth++;
20413                 if (r->in.server) {
20414                         ndr_print_string(ndr, "server", r->in.server);
20415                 }
20416                 ndr->depth--;
20417                 ndr_print_uint32(ndr, "level", r->in.level);
20418                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20419                 ndr->depth++;
20420                 if (r->in.buffer) {
20421                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20422                 }
20423                 ndr->depth--;
20424                 ndr_print_uint32(ndr, "offered", r->in.offered);
20425                 ndr->depth--;
20426         }
20427         if (flags & NDR_OUT) {
20428                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
20429                 ndr->depth++;
20430                 ndr_print_ptr(ndr, "count", r->out.count);
20431                 ndr->depth++;
20432                 ndr_print_uint32(ndr, "count", *r->out.count);
20433                 ndr->depth--;
20434                 ndr_print_ptr(ndr, "info", r->out.info);
20435                 ndr->depth++;
20436                 ndr_print_ptr(ndr, "info", *r->out.info);
20437                 ndr->depth++;
20438                 if (*r->out.info) {
20439                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20440                         ndr->depth++;
20441                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20442                                 char *idx_2=NULL;
20443                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20444                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20445                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20446                                         free(idx_2);
20447                                 }
20448                         }
20449                         ndr->depth--;
20450                 }
20451                 ndr->depth--;
20452                 ndr->depth--;
20453                 ndr_print_ptr(ndr, "needed", r->out.needed);
20454                 ndr->depth++;
20455                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20456                 ndr->depth--;
20457                 ndr_print_WERROR(ndr, "result", r->out.result);
20458                 ndr->depth--;
20459         }
20460         ndr->depth--;
20461 }
20462
20463 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
20464 {
20465         if (flags & NDR_IN) {
20466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
20467                 if (r->in.printername) {
20468                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
20471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20472                 }
20473                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
20474                 if (r->in.datatype) {
20475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
20477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
20478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20479                 }
20480                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20481                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
20482         }
20483         if (flags & NDR_OUT) {
20484                 if (r->out.handle == NULL) {
20485                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20486                 }
20487                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20488                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20489         }
20490         return NDR_ERR_SUCCESS;
20491 }
20492
20493 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
20494 {
20495         uint32_t _ptr_printername;
20496         uint32_t _ptr_datatype;
20497         TALLOC_CTX *_mem_save_printername_0;
20498         TALLOC_CTX *_mem_save_datatype_0;
20499         TALLOC_CTX *_mem_save_handle_0;
20500         if (flags & NDR_IN) {
20501                 ZERO_STRUCT(r->out);
20502
20503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
20504                 if (_ptr_printername) {
20505                         NDR_PULL_ALLOC(ndr, r->in.printername);
20506                 } else {
20507                         r->in.printername = NULL;
20508                 }
20509                 if (r->in.printername) {
20510                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20511                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
20512                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
20513                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
20514                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
20515                                 return 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));
20516                         }
20517                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
20518                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
20519                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
20520                 }
20521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
20522                 if (_ptr_datatype) {
20523                         NDR_PULL_ALLOC(ndr, r->in.datatype);
20524                 } else {
20525                         r->in.datatype = NULL;
20526                 }
20527                 if (r->in.datatype) {
20528                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
20529                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
20530                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
20531                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
20532                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
20533                                 return 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));
20534                         }
20535                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
20536                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
20537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
20538                 }
20539                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
20540                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
20541                 NDR_PULL_ALLOC(ndr, r->out.handle);
20542                 ZERO_STRUCTP(r->out.handle);
20543         }
20544         if (flags & NDR_OUT) {
20545                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20546                         NDR_PULL_ALLOC(ndr, r->out.handle);
20547                 }
20548                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20549                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20550                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20551                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20552                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20553         }
20554         return NDR_ERR_SUCCESS;
20555 }
20556
20557 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
20558 {
20559         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
20560         ndr->depth++;
20561         if (flags & NDR_SET_VALUES) {
20562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20563         }
20564         if (flags & NDR_IN) {
20565                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
20566                 ndr->depth++;
20567                 ndr_print_ptr(ndr, "printername", r->in.printername);
20568                 ndr->depth++;
20569                 if (r->in.printername) {
20570                         ndr_print_string(ndr, "printername", r->in.printername);
20571                 }
20572                 ndr->depth--;
20573                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
20574                 ndr->depth++;
20575                 if (r->in.datatype) {
20576                         ndr_print_string(ndr, "datatype", r->in.datatype);
20577                 }
20578                 ndr->depth--;
20579                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
20580                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
20581                 ndr->depth--;
20582         }
20583         if (flags & NDR_OUT) {
20584                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
20585                 ndr->depth++;
20586                 ndr_print_ptr(ndr, "handle", r->out.handle);
20587                 ndr->depth++;
20588                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20589                 ndr->depth--;
20590                 ndr_print_WERROR(ndr, "result", r->out.result);
20591                 ndr->depth--;
20592         }
20593         ndr->depth--;
20594 }
20595
20596 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
20597 {
20598         if (flags & NDR_IN) {
20599                 if (r->in.handle == NULL) {
20600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20601                 }
20602                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
20605                 if (r->in.ctr) {
20606                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20607                 }
20608                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
20609         }
20610         if (flags & NDR_OUT) {
20611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20612         }
20613         return NDR_ERR_SUCCESS;
20614 }
20615
20616 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
20617 {
20618         uint32_t _ptr_ctr;
20619         TALLOC_CTX *_mem_save_handle_0;
20620         TALLOC_CTX *_mem_save_ctr_0;
20621         if (flags & NDR_IN) {
20622                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20623                         NDR_PULL_ALLOC(ndr, r->in.handle);
20624                 }
20625                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20626                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20627                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20628                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
20631                 if (_ptr_ctr) {
20632                         NDR_PULL_ALLOC(ndr, r->in.ctr);
20633                 } else {
20634                         r->in.ctr = NULL;
20635                 }
20636                 if (r->in.ctr) {
20637                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20638                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
20639                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
20640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
20641                 }
20642                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
20643         }
20644         if (flags & NDR_OUT) {
20645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20646         }
20647         return NDR_ERR_SUCCESS;
20648 }
20649
20650 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
20651 {
20652         ndr_print_struct(ndr, name, "spoolss_SetJob");
20653         ndr->depth++;
20654         if (flags & NDR_SET_VALUES) {
20655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20656         }
20657         if (flags & NDR_IN) {
20658                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
20659                 ndr->depth++;
20660                 ndr_print_ptr(ndr, "handle", r->in.handle);
20661                 ndr->depth++;
20662                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20663                 ndr->depth--;
20664                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20665                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
20666                 ndr->depth++;
20667                 if (r->in.ctr) {
20668                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
20669                 }
20670                 ndr->depth--;
20671                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
20672                 ndr->depth--;
20673         }
20674         if (flags & NDR_OUT) {
20675                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
20676                 ndr->depth++;
20677                 ndr_print_WERROR(ndr, "result", r->out.result);
20678                 ndr->depth--;
20679         }
20680         ndr->depth--;
20681 }
20682
20683 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
20684 {
20685         if (flags & NDR_IN) {
20686                 if (r->in.handle == NULL) {
20687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20688                 }
20689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
20691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20693                 if (r->in.buffer) {
20694                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20695                 }
20696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20697         }
20698         if (flags & NDR_OUT) {
20699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20700                 if (r->out.info) {
20701                         {
20702                                 struct ndr_push *_ndr_info;
20703                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20704                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20705                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20706                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20707                         }
20708                 }
20709                 if (r->out.needed == NULL) {
20710                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20711                 }
20712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20714         }
20715         return NDR_ERR_SUCCESS;
20716 }
20717
20718 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
20719 {
20720         uint32_t _ptr_buffer;
20721         uint32_t _ptr_info;
20722         TALLOC_CTX *_mem_save_handle_0;
20723         TALLOC_CTX *_mem_save_buffer_0;
20724         TALLOC_CTX *_mem_save_info_0;
20725         TALLOC_CTX *_mem_save_needed_0;
20726         if (flags & NDR_IN) {
20727                 ZERO_STRUCT(r->out);
20728
20729                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20730                         NDR_PULL_ALLOC(ndr, r->in.handle);
20731                 }
20732                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20733                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20734                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
20737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20739                 if (_ptr_buffer) {
20740                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20741                 } else {
20742                         r->in.buffer = NULL;
20743                 }
20744                 if (r->in.buffer) {
20745                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20747                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20749                 }
20750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20751                 NDR_PULL_ALLOC(ndr, r->out.needed);
20752                 ZERO_STRUCTP(r->out.needed);
20753         }
20754         if (flags & NDR_OUT) {
20755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20756                 if (_ptr_info) {
20757                         NDR_PULL_ALLOC(ndr, r->out.info);
20758                 } else {
20759                         r->out.info = NULL;
20760                 }
20761                 if (r->out.info) {
20762                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20763                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20764                         {
20765                                 struct ndr_pull *_ndr_info;
20766                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20767                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20768                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20769                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20770                         }
20771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20772                 }
20773                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20774                         NDR_PULL_ALLOC(ndr, r->out.needed);
20775                 }
20776                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20777                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20779                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20780                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20781         }
20782         return NDR_ERR_SUCCESS;
20783 }
20784
20785 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
20786 {
20787         ndr_print_struct(ndr, name, "spoolss_GetJob");
20788         ndr->depth++;
20789         if (flags & NDR_SET_VALUES) {
20790                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20791         }
20792         if (flags & NDR_IN) {
20793                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
20794                 ndr->depth++;
20795                 ndr_print_ptr(ndr, "handle", r->in.handle);
20796                 ndr->depth++;
20797                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20798                 ndr->depth--;
20799                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
20800                 ndr_print_uint32(ndr, "level", r->in.level);
20801                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20802                 ndr->depth++;
20803                 if (r->in.buffer) {
20804                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20805                 }
20806                 ndr->depth--;
20807                 ndr_print_uint32(ndr, "offered", r->in.offered);
20808                 ndr->depth--;
20809         }
20810         if (flags & NDR_OUT) {
20811                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
20812                 ndr->depth++;
20813                 ndr_print_ptr(ndr, "info", r->out.info);
20814                 ndr->depth++;
20815                 if (r->out.info) {
20816                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20817                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
20818                 }
20819                 ndr->depth--;
20820                 ndr_print_ptr(ndr, "needed", r->out.needed);
20821                 ndr->depth++;
20822                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20823                 ndr->depth--;
20824                 ndr_print_WERROR(ndr, "result", r->out.result);
20825                 ndr->depth--;
20826         }
20827         ndr->depth--;
20828 }
20829
20830 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
20831 {
20832         if (flags & NDR_IN) {
20833                 if (r->in.handle == NULL) {
20834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20835                 }
20836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
20838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
20839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20841                 if (r->in.buffer) {
20842                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20843                 }
20844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20845         }
20846         if (flags & NDR_OUT) {
20847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20848                 if (r->out.info) {
20849                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20850                 }
20851                 if (r->out.needed == NULL) {
20852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20853                 }
20854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20855                 if (r->out.count == NULL) {
20856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20857                 }
20858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20859                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20860         }
20861         return NDR_ERR_SUCCESS;
20862 }
20863
20864 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
20865 {
20866         uint32_t _ptr_buffer;
20867         uint32_t _ptr_info;
20868         TALLOC_CTX *_mem_save_handle_0;
20869         TALLOC_CTX *_mem_save_buffer_0;
20870         TALLOC_CTX *_mem_save_info_0;
20871         TALLOC_CTX *_mem_save_needed_0;
20872         TALLOC_CTX *_mem_save_count_0;
20873         if (flags & NDR_IN) {
20874                 ZERO_STRUCT(r->out);
20875
20876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20877                         NDR_PULL_ALLOC(ndr, r->in.handle);
20878                 }
20879                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20880                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20881                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
20884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
20885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20887                 if (_ptr_buffer) {
20888                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20889                 } else {
20890                         r->in.buffer = NULL;
20891                 }
20892                 if (r->in.buffer) {
20893                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20894                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20895                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20897                 }
20898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20899                 NDR_PULL_ALLOC(ndr, r->out.needed);
20900                 ZERO_STRUCTP(r->out.needed);
20901                 NDR_PULL_ALLOC(ndr, r->out.count);
20902                 ZERO_STRUCTP(r->out.count);
20903         }
20904         if (flags & NDR_OUT) {
20905                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20906                 if (_ptr_info) {
20907                         NDR_PULL_ALLOC(ndr, r->out.info);
20908                 } else {
20909                         r->out.info = NULL;
20910                 }
20911                 if (r->out.info) {
20912                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20913                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20914                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20916                 }
20917                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20918                         NDR_PULL_ALLOC(ndr, r->out.needed);
20919                 }
20920                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20921                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20925                         NDR_PULL_ALLOC(ndr, r->out.count);
20926                 }
20927                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20928                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20931                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20932         }
20933         return NDR_ERR_SUCCESS;
20934 }
20935
20936 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
20937 {
20938         uint32_t cntr_info_0;
20939         if (flags & NDR_IN) {
20940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20942         }
20943         if (flags & NDR_OUT) {
20944                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20945                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20946                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20947                 }
20948                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20949                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20950                 }
20951         }
20952         return NDR_ERR_SUCCESS;
20953 }
20954
20955 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
20956 {
20957         uint32_t cntr_info_0;
20958         TALLOC_CTX *_mem_save_info_0;
20959         if (flags & NDR_IN) {
20960                 ZERO_STRUCT(r->out);
20961
20962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20964         }
20965         if (flags & NDR_OUT) {
20966                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20967                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20968                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20969                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20970                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20971                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20972                 }
20973                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20974                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20975                 }
20976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20977         }
20978         return NDR_ERR_SUCCESS;
20979 }
20980
20981 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
20982 {
20983         uint32_t cntr_info_2;
20984         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
20985         ndr->depth++;
20986         if (flags & NDR_SET_VALUES) {
20987                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20988         }
20989         if (flags & NDR_IN) {
20990                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
20991                 ndr->depth++;
20992                 ndr_print_ptr(ndr, "handle", r->in.handle);
20993                 ndr->depth++;
20994                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20995                 ndr->depth--;
20996                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
20997                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
20998                 ndr_print_uint32(ndr, "level", r->in.level);
20999                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21000                 ndr->depth++;
21001                 if (r->in.buffer) {
21002                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21003                 }
21004                 ndr->depth--;
21005                 ndr_print_uint32(ndr, "offered", r->in.offered);
21006                 ndr->depth--;
21007         }
21008         if (flags & NDR_OUT) {
21009                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
21010                 ndr->depth++;
21011                 ndr_print_ptr(ndr, "count", r->out.count);
21012                 ndr->depth++;
21013                 ndr_print_uint32(ndr, "count", *r->out.count);
21014                 ndr->depth--;
21015                 ndr_print_ptr(ndr, "info", r->out.info);
21016                 ndr->depth++;
21017                 ndr_print_ptr(ndr, "info", *r->out.info);
21018                 ndr->depth++;
21019                 if (*r->out.info) {
21020                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21021                         ndr->depth++;
21022                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21023                                 char *idx_2=NULL;
21024                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21025                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21026                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21027                                         free(idx_2);
21028                                 }
21029                         }
21030                         ndr->depth--;
21031                 }
21032                 ndr->depth--;
21033                 ndr->depth--;
21034                 ndr_print_ptr(ndr, "needed", r->out.needed);
21035                 ndr->depth++;
21036                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21037                 ndr->depth--;
21038                 ndr_print_WERROR(ndr, "result", r->out.result);
21039                 ndr->depth--;
21040         }
21041         ndr->depth--;
21042 }
21043
21044 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
21045 {
21046         if (flags & NDR_IN) {
21047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21048                 if (r->in.server) {
21049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21053                 }
21054                 if (r->in.info_ctr == NULL) {
21055                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21056                 }
21057                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21058                 if (r->in.devmode_ctr == NULL) {
21059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21060                 }
21061                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21062                 if (r->in.secdesc_ctr == NULL) {
21063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21064                 }
21065                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21066         }
21067         if (flags & NDR_OUT) {
21068                 if (r->out.handle == NULL) {
21069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21070                 }
21071                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21073         }
21074         return NDR_ERR_SUCCESS;
21075 }
21076
21077 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
21078 {
21079         uint32_t _ptr_server;
21080         TALLOC_CTX *_mem_save_server_0;
21081         TALLOC_CTX *_mem_save_info_ctr_0;
21082         TALLOC_CTX *_mem_save_devmode_ctr_0;
21083         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21084         TALLOC_CTX *_mem_save_handle_0;
21085         if (flags & NDR_IN) {
21086                 ZERO_STRUCT(r->out);
21087
21088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21089                 if (_ptr_server) {
21090                         NDR_PULL_ALLOC(ndr, r->in.server);
21091                 } else {
21092                         r->in.server = NULL;
21093                 }
21094                 if (r->in.server) {
21095                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21099                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21100                                 return 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));
21101                         }
21102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21103                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21105                 }
21106                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21107                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21108                 }
21109                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21110                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21111                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21112                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21113                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21114                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21115                 }
21116                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21117                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21118                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21121                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21122                 }
21123                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21124                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21125                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21127                 NDR_PULL_ALLOC(ndr, r->out.handle);
21128                 ZERO_STRUCTP(r->out.handle);
21129         }
21130         if (flags & NDR_OUT) {
21131                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21132                         NDR_PULL_ALLOC(ndr, r->out.handle);
21133                 }
21134                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21135                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21136                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21139         }
21140         return NDR_ERR_SUCCESS;
21141 }
21142
21143 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
21144 {
21145         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
21146         ndr->depth++;
21147         if (flags & NDR_SET_VALUES) {
21148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21149         }
21150         if (flags & NDR_IN) {
21151                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
21152                 ndr->depth++;
21153                 ndr_print_ptr(ndr, "server", r->in.server);
21154                 ndr->depth++;
21155                 if (r->in.server) {
21156                         ndr_print_string(ndr, "server", r->in.server);
21157                 }
21158                 ndr->depth--;
21159                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21160                 ndr->depth++;
21161                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21162                 ndr->depth--;
21163                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21164                 ndr->depth++;
21165                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21166                 ndr->depth--;
21167                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21168                 ndr->depth++;
21169                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21170                 ndr->depth--;
21171                 ndr->depth--;
21172         }
21173         if (flags & NDR_OUT) {
21174                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
21175                 ndr->depth++;
21176                 ndr_print_ptr(ndr, "handle", r->out.handle);
21177                 ndr->depth++;
21178                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21179                 ndr->depth--;
21180                 ndr_print_WERROR(ndr, "result", r->out.result);
21181                 ndr->depth--;
21182         }
21183         ndr->depth--;
21184 }
21185
21186 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
21187 {
21188         if (flags & NDR_IN) {
21189                 if (r->in.handle == NULL) {
21190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21191                 }
21192                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21193         }
21194         if (flags & NDR_OUT) {
21195                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21196         }
21197         return NDR_ERR_SUCCESS;
21198 }
21199
21200 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
21201 {
21202         TALLOC_CTX *_mem_save_handle_0;
21203         if (flags & NDR_IN) {
21204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21205                         NDR_PULL_ALLOC(ndr, r->in.handle);
21206                 }
21207                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21208                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21209                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21211         }
21212         if (flags & NDR_OUT) {
21213                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21214         }
21215         return NDR_ERR_SUCCESS;
21216 }
21217
21218 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
21219 {
21220         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
21221         ndr->depth++;
21222         if (flags & NDR_SET_VALUES) {
21223                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21224         }
21225         if (flags & NDR_IN) {
21226                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
21227                 ndr->depth++;
21228                 ndr_print_ptr(ndr, "handle", r->in.handle);
21229                 ndr->depth++;
21230                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21231                 ndr->depth--;
21232                 ndr->depth--;
21233         }
21234         if (flags & NDR_OUT) {
21235                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
21236                 ndr->depth++;
21237                 ndr_print_WERROR(ndr, "result", r->out.result);
21238                 ndr->depth--;
21239         }
21240         ndr->depth--;
21241 }
21242
21243 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
21244 {
21245         if (flags & NDR_IN) {
21246                 if (r->in.handle == NULL) {
21247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21248                 }
21249                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21250                 if (r->in.info_ctr == NULL) {
21251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21252                 }
21253                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21254                 if (r->in.devmode_ctr == NULL) {
21255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21256                 }
21257                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21258                 if (r->in.secdesc_ctr == NULL) {
21259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21260                 }
21261                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21262                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
21263         }
21264         if (flags & NDR_OUT) {
21265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21266         }
21267         return NDR_ERR_SUCCESS;
21268 }
21269
21270 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
21271 {
21272         TALLOC_CTX *_mem_save_handle_0;
21273         TALLOC_CTX *_mem_save_info_ctr_0;
21274         TALLOC_CTX *_mem_save_devmode_ctr_0;
21275         TALLOC_CTX *_mem_save_secdesc_ctr_0;
21276         if (flags & NDR_IN) {
21277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21278                         NDR_PULL_ALLOC(ndr, r->in.handle);
21279                 }
21280                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21281                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21282                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21284                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21285                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21286                 }
21287                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21288                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21289                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21290                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21292                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21293                 }
21294                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21295                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21296                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21298                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21299                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
21300                 }
21301                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21302                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
21303                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
21304                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21305                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
21306         }
21307         if (flags & NDR_OUT) {
21308                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21309         }
21310         return NDR_ERR_SUCCESS;
21311 }
21312
21313 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
21314 {
21315         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
21316         ndr->depth++;
21317         if (flags & NDR_SET_VALUES) {
21318                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21319         }
21320         if (flags & NDR_IN) {
21321                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
21322                 ndr->depth++;
21323                 ndr_print_ptr(ndr, "handle", r->in.handle);
21324                 ndr->depth++;
21325                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21326                 ndr->depth--;
21327                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21328                 ndr->depth++;
21329                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21330                 ndr->depth--;
21331                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21332                 ndr->depth++;
21333                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21334                 ndr->depth--;
21335                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21336                 ndr->depth++;
21337                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
21338                 ndr->depth--;
21339                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
21340                 ndr->depth--;
21341         }
21342         if (flags & NDR_OUT) {
21343                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
21344                 ndr->depth++;
21345                 ndr_print_WERROR(ndr, "result", r->out.result);
21346                 ndr->depth--;
21347         }
21348         ndr->depth--;
21349 }
21350
21351 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
21352 {
21353         if (flags & NDR_IN) {
21354                 if (r->in.handle == NULL) {
21355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21356                 }
21357                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21360                 if (r->in.buffer) {
21361                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21362                 }
21363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21364         }
21365         if (flags & NDR_OUT) {
21366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21367                 if (r->out.info) {
21368                         {
21369                                 struct ndr_push *_ndr_info;
21370                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21371                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21372                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21373                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21374                         }
21375                 }
21376                 if (r->out.needed == NULL) {
21377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21378                 }
21379                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21380                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21381         }
21382         return NDR_ERR_SUCCESS;
21383 }
21384
21385 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
21386 {
21387         uint32_t _ptr_buffer;
21388         uint32_t _ptr_info;
21389         TALLOC_CTX *_mem_save_handle_0;
21390         TALLOC_CTX *_mem_save_buffer_0;
21391         TALLOC_CTX *_mem_save_info_0;
21392         TALLOC_CTX *_mem_save_needed_0;
21393         if (flags & NDR_IN) {
21394                 ZERO_STRUCT(r->out);
21395
21396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21397                         NDR_PULL_ALLOC(ndr, r->in.handle);
21398                 }
21399                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21401                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21405                 if (_ptr_buffer) {
21406                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21407                 } else {
21408                         r->in.buffer = NULL;
21409                 }
21410                 if (r->in.buffer) {
21411                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21412                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21413                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21415                 }
21416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21417                 NDR_PULL_ALLOC(ndr, r->out.needed);
21418                 ZERO_STRUCTP(r->out.needed);
21419         }
21420         if (flags & NDR_OUT) {
21421                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21422                 if (_ptr_info) {
21423                         NDR_PULL_ALLOC(ndr, r->out.info);
21424                 } else {
21425                         r->out.info = NULL;
21426                 }
21427                 if (r->out.info) {
21428                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21429                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21430                         {
21431                                 struct ndr_pull *_ndr_info;
21432                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21433                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21434                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21435                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21436                         }
21437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21438                 }
21439                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21440                         NDR_PULL_ALLOC(ndr, r->out.needed);
21441                 }
21442                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21443                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21445                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21447         }
21448         return NDR_ERR_SUCCESS;
21449 }
21450
21451 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
21452 {
21453         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
21454         ndr->depth++;
21455         if (flags & NDR_SET_VALUES) {
21456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21457         }
21458         if (flags & NDR_IN) {
21459                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
21460                 ndr->depth++;
21461                 ndr_print_ptr(ndr, "handle", r->in.handle);
21462                 ndr->depth++;
21463                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21464                 ndr->depth--;
21465                 ndr_print_uint32(ndr, "level", r->in.level);
21466                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21467                 ndr->depth++;
21468                 if (r->in.buffer) {
21469                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21470                 }
21471                 ndr->depth--;
21472                 ndr_print_uint32(ndr, "offered", r->in.offered);
21473                 ndr->depth--;
21474         }
21475         if (flags & NDR_OUT) {
21476                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
21477                 ndr->depth++;
21478                 ndr_print_ptr(ndr, "info", r->out.info);
21479                 ndr->depth++;
21480                 if (r->out.info) {
21481                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21482                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
21483                 }
21484                 ndr->depth--;
21485                 ndr_print_ptr(ndr, "needed", r->out.needed);
21486                 ndr->depth++;
21487                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21488                 ndr->depth--;
21489                 ndr_print_WERROR(ndr, "result", r->out.result);
21490                 ndr->depth--;
21491         }
21492         ndr->depth--;
21493 }
21494
21495 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
21496 {
21497         if (flags & NDR_IN) {
21498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
21499                 if (r->in.servername) {
21500                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21501                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21502                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
21503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21504                 }
21505                 if (r->in.info_ctr == NULL) {
21506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21507                 }
21508                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21509         }
21510         if (flags & NDR_OUT) {
21511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21512         }
21513         return NDR_ERR_SUCCESS;
21514 }
21515
21516 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
21517 {
21518         uint32_t _ptr_servername;
21519         TALLOC_CTX *_mem_save_servername_0;
21520         TALLOC_CTX *_mem_save_info_ctr_0;
21521         if (flags & NDR_IN) {
21522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
21523                 if (_ptr_servername) {
21524                         NDR_PULL_ALLOC(ndr, r->in.servername);
21525                 } else {
21526                         r->in.servername = NULL;
21527                 }
21528                 if (r->in.servername) {
21529                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
21530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
21531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
21532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
21533                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
21534                                 return 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));
21535                         }
21536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
21537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
21538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
21539                 }
21540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21541                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
21542                 }
21543                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21544                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
21545                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
21546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21547         }
21548         if (flags & NDR_OUT) {
21549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21550         }
21551         return NDR_ERR_SUCCESS;
21552 }
21553
21554 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
21555 {
21556         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
21557         ndr->depth++;
21558         if (flags & NDR_SET_VALUES) {
21559                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21560         }
21561         if (flags & NDR_IN) {
21562                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
21563                 ndr->depth++;
21564                 ndr_print_ptr(ndr, "servername", r->in.servername);
21565                 ndr->depth++;
21566                 if (r->in.servername) {
21567                         ndr_print_string(ndr, "servername", r->in.servername);
21568                 }
21569                 ndr->depth--;
21570                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
21571                 ndr->depth++;
21572                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
21573                 ndr->depth--;
21574                 ndr->depth--;
21575         }
21576         if (flags & NDR_OUT) {
21577                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
21578                 ndr->depth++;
21579                 ndr_print_WERROR(ndr, "result", r->out.result);
21580                 ndr->depth--;
21581         }
21582         ndr->depth--;
21583 }
21584
21585 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
21586 {
21587         if (flags & NDR_IN) {
21588                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21589                 if (r->in.server) {
21590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21593                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21594                 }
21595                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21596                 if (r->in.environment) {
21597                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21599                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21600                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21601                 }
21602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21604                 if (r->in.buffer) {
21605                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21606                 }
21607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21608         }
21609         if (flags & NDR_OUT) {
21610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21611                 if (r->out.info) {
21612                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
21613                 }
21614                 if (r->out.needed == NULL) {
21615                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21616                 }
21617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21618                 if (r->out.count == NULL) {
21619                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21620                 }
21621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
21622                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21623         }
21624         return NDR_ERR_SUCCESS;
21625 }
21626
21627 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
21628 {
21629         uint32_t _ptr_server;
21630         uint32_t _ptr_environment;
21631         uint32_t _ptr_buffer;
21632         uint32_t _ptr_info;
21633         TALLOC_CTX *_mem_save_server_0;
21634         TALLOC_CTX *_mem_save_environment_0;
21635         TALLOC_CTX *_mem_save_buffer_0;
21636         TALLOC_CTX *_mem_save_info_0;
21637         TALLOC_CTX *_mem_save_needed_0;
21638         TALLOC_CTX *_mem_save_count_0;
21639         if (flags & NDR_IN) {
21640                 ZERO_STRUCT(r->out);
21641
21642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21643                 if (_ptr_server) {
21644                         NDR_PULL_ALLOC(ndr, r->in.server);
21645                 } else {
21646                         r->in.server = NULL;
21647                 }
21648                 if (r->in.server) {
21649                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21653                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21654                                 return 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));
21655                         }
21656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21659                 }
21660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21661                 if (_ptr_environment) {
21662                         NDR_PULL_ALLOC(ndr, r->in.environment);
21663                 } else {
21664                         r->in.environment = NULL;
21665                 }
21666                 if (r->in.environment) {
21667                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21668                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21671                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21672                                 return 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));
21673                         }
21674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21677                 }
21678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21679                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21680                 if (_ptr_buffer) {
21681                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21682                 } else {
21683                         r->in.buffer = NULL;
21684                 }
21685                 if (r->in.buffer) {
21686                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21687                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21688                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21690                 }
21691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21692                 NDR_PULL_ALLOC(ndr, r->out.needed);
21693                 ZERO_STRUCTP(r->out.needed);
21694                 NDR_PULL_ALLOC(ndr, r->out.count);
21695                 ZERO_STRUCTP(r->out.count);
21696         }
21697         if (flags & NDR_OUT) {
21698                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21699                 if (_ptr_info) {
21700                         NDR_PULL_ALLOC(ndr, r->out.info);
21701                 } else {
21702                         r->out.info = NULL;
21703                 }
21704                 if (r->out.info) {
21705                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21706                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21707                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21709                 }
21710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21711                         NDR_PULL_ALLOC(ndr, r->out.needed);
21712                 }
21713                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21714                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21718                         NDR_PULL_ALLOC(ndr, r->out.count);
21719                 }
21720                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21721                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21724                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21725         }
21726         return NDR_ERR_SUCCESS;
21727 }
21728
21729 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
21730 {
21731         uint32_t cntr_info_0;
21732         if (flags & NDR_IN) {
21733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21735         }
21736         if (flags & NDR_OUT) {
21737                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21738                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21739                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21740                 }
21741                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21742                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21743                 }
21744         }
21745         return NDR_ERR_SUCCESS;
21746 }
21747
21748 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
21749 {
21750         uint32_t cntr_info_0;
21751         TALLOC_CTX *_mem_save_info_0;
21752         if (flags & NDR_IN) {
21753                 ZERO_STRUCT(r->out);
21754
21755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21757         }
21758         if (flags & NDR_OUT) {
21759                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21760                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21761                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21762                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21763                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21764                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21765                 }
21766                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21767                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21768                 }
21769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21770         }
21771         return NDR_ERR_SUCCESS;
21772 }
21773
21774 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
21775 {
21776         uint32_t cntr_info_2;
21777         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
21778         ndr->depth++;
21779         if (flags & NDR_SET_VALUES) {
21780                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21781         }
21782         if (flags & NDR_IN) {
21783                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
21784                 ndr->depth++;
21785                 ndr_print_ptr(ndr, "server", r->in.server);
21786                 ndr->depth++;
21787                 if (r->in.server) {
21788                         ndr_print_string(ndr, "server", r->in.server);
21789                 }
21790                 ndr->depth--;
21791                 ndr_print_ptr(ndr, "environment", r->in.environment);
21792                 ndr->depth++;
21793                 if (r->in.environment) {
21794                         ndr_print_string(ndr, "environment", r->in.environment);
21795                 }
21796                 ndr->depth--;
21797                 ndr_print_uint32(ndr, "level", r->in.level);
21798                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21799                 ndr->depth++;
21800                 if (r->in.buffer) {
21801                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21802                 }
21803                 ndr->depth--;
21804                 ndr_print_uint32(ndr, "offered", r->in.offered);
21805                 ndr->depth--;
21806         }
21807         if (flags & NDR_OUT) {
21808                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
21809                 ndr->depth++;
21810                 ndr_print_ptr(ndr, "count", r->out.count);
21811                 ndr->depth++;
21812                 ndr_print_uint32(ndr, "count", *r->out.count);
21813                 ndr->depth--;
21814                 ndr_print_ptr(ndr, "info", r->out.info);
21815                 ndr->depth++;
21816                 ndr_print_ptr(ndr, "info", *r->out.info);
21817                 ndr->depth++;
21818                 if (*r->out.info) {
21819                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21820                         ndr->depth++;
21821                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21822                                 char *idx_2=NULL;
21823                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21824                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21825                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21826                                         free(idx_2);
21827                                 }
21828                         }
21829                         ndr->depth--;
21830                 }
21831                 ndr->depth--;
21832                 ndr->depth--;
21833                 ndr_print_ptr(ndr, "needed", r->out.needed);
21834                 ndr->depth++;
21835                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21836                 ndr->depth--;
21837                 ndr_print_WERROR(ndr, "result", r->out.result);
21838                 ndr->depth--;
21839         }
21840         ndr->depth--;
21841 }
21842
21843 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
21844 {
21845         if (flags & NDR_IN) {
21846                 if (r->in.handle == NULL) {
21847                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21848                 }
21849                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21851                 if (r->in.architecture) {
21852                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
21854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21856                 }
21857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21858                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21859                 if (r->in.buffer) {
21860                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21861                 }
21862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21863         }
21864         if (flags & NDR_OUT) {
21865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21866                 if (r->out.info) {
21867                         {
21868                                 struct ndr_push *_ndr_info;
21869                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21870                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21871                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21872                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21873                         }
21874                 }
21875                 if (r->out.needed == NULL) {
21876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21877                 }
21878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21879                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21880         }
21881         return NDR_ERR_SUCCESS;
21882 }
21883
21884 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
21885 {
21886         uint32_t _ptr_architecture;
21887         uint32_t _ptr_buffer;
21888         uint32_t _ptr_info;
21889         TALLOC_CTX *_mem_save_handle_0;
21890         TALLOC_CTX *_mem_save_architecture_0;
21891         TALLOC_CTX *_mem_save_buffer_0;
21892         TALLOC_CTX *_mem_save_info_0;
21893         TALLOC_CTX *_mem_save_needed_0;
21894         if (flags & NDR_IN) {
21895                 ZERO_STRUCT(r->out);
21896
21897                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21898                         NDR_PULL_ALLOC(ndr, r->in.handle);
21899                 }
21900                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21901                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21902                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21903                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21905                 if (_ptr_architecture) {
21906                         NDR_PULL_ALLOC(ndr, r->in.architecture);
21907                 } else {
21908                         r->in.architecture = NULL;
21909                 }
21910                 if (r->in.architecture) {
21911                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
21912                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
21913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
21914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
21915                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
21916                                 return 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));
21917                         }
21918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
21919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
21920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
21921                 }
21922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21924                 if (_ptr_buffer) {
21925                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21926                 } else {
21927                         r->in.buffer = NULL;
21928                 }
21929                 if (r->in.buffer) {
21930                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21931                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21932                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21934                 }
21935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21936                 NDR_PULL_ALLOC(ndr, r->out.needed);
21937                 ZERO_STRUCTP(r->out.needed);
21938         }
21939         if (flags & NDR_OUT) {
21940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21941                 if (_ptr_info) {
21942                         NDR_PULL_ALLOC(ndr, r->out.info);
21943                 } else {
21944                         r->out.info = NULL;
21945                 }
21946                 if (r->out.info) {
21947                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21948                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21949                         {
21950                                 struct ndr_pull *_ndr_info;
21951                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21952                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21953                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21954                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21955                         }
21956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21957                 }
21958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21959                         NDR_PULL_ALLOC(ndr, r->out.needed);
21960                 }
21961                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21962                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21966         }
21967         return NDR_ERR_SUCCESS;
21968 }
21969
21970 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
21971 {
21972         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
21973         ndr->depth++;
21974         if (flags & NDR_SET_VALUES) {
21975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21976         }
21977         if (flags & NDR_IN) {
21978                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
21979                 ndr->depth++;
21980                 ndr_print_ptr(ndr, "handle", r->in.handle);
21981                 ndr->depth++;
21982                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21983                 ndr->depth--;
21984                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
21985                 ndr->depth++;
21986                 if (r->in.architecture) {
21987                         ndr_print_string(ndr, "architecture", r->in.architecture);
21988                 }
21989                 ndr->depth--;
21990                 ndr_print_uint32(ndr, "level", r->in.level);
21991                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21992                 ndr->depth++;
21993                 if (r->in.buffer) {
21994                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21995                 }
21996                 ndr->depth--;
21997                 ndr_print_uint32(ndr, "offered", r->in.offered);
21998                 ndr->depth--;
21999         }
22000         if (flags & NDR_OUT) {
22001                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
22002                 ndr->depth++;
22003                 ndr_print_ptr(ndr, "info", r->out.info);
22004                 ndr->depth++;
22005                 if (r->out.info) {
22006                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22007                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22008                 }
22009                 ndr->depth--;
22010                 ndr_print_ptr(ndr, "needed", r->out.needed);
22011                 ndr->depth++;
22012                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22013                 ndr->depth--;
22014                 ndr_print_WERROR(ndr, "result", r->out.result);
22015                 ndr->depth--;
22016         }
22017         ndr->depth--;
22018 }
22019
22020 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22021 {
22022         if (flags & NDR_IN) {
22023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22024                 if (r->in.server) {
22025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22028                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22029                 }
22030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22031                 if (r->in.environment) {
22032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22035                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22036                 }
22037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22039                 if (r->in.buffer) {
22040                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22041                 }
22042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22043         }
22044         if (flags & NDR_OUT) {
22045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22046                 if (r->out.info) {
22047                         {
22048                                 struct ndr_push *_ndr_info;
22049                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22050                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22051                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22052                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22053                         }
22054                 }
22055                 if (r->out.needed == NULL) {
22056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22057                 }
22058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22060         }
22061         return NDR_ERR_SUCCESS;
22062 }
22063
22064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
22065 {
22066         uint32_t _ptr_server;
22067         uint32_t _ptr_environment;
22068         uint32_t _ptr_buffer;
22069         uint32_t _ptr_info;
22070         TALLOC_CTX *_mem_save_server_0;
22071         TALLOC_CTX *_mem_save_environment_0;
22072         TALLOC_CTX *_mem_save_buffer_0;
22073         TALLOC_CTX *_mem_save_info_0;
22074         TALLOC_CTX *_mem_save_needed_0;
22075         if (flags & NDR_IN) {
22076                 ZERO_STRUCT(r->out);
22077
22078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22079                 if (_ptr_server) {
22080                         NDR_PULL_ALLOC(ndr, r->in.server);
22081                 } else {
22082                         r->in.server = NULL;
22083                 }
22084                 if (r->in.server) {
22085                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22086                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22088                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22089                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22090                                 return 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));
22091                         }
22092                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22093                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22095                 }
22096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22097                 if (_ptr_environment) {
22098                         NDR_PULL_ALLOC(ndr, r->in.environment);
22099                 } else {
22100                         r->in.environment = NULL;
22101                 }
22102                 if (r->in.environment) {
22103                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22104                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22107                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22108                                 return 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));
22109                         }
22110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22111                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22113                 }
22114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22116                 if (_ptr_buffer) {
22117                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22118                 } else {
22119                         r->in.buffer = NULL;
22120                 }
22121                 if (r->in.buffer) {
22122                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22123                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22124                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22125                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22126                 }
22127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22128                 NDR_PULL_ALLOC(ndr, r->out.needed);
22129                 ZERO_STRUCTP(r->out.needed);
22130         }
22131         if (flags & NDR_OUT) {
22132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22133                 if (_ptr_info) {
22134                         NDR_PULL_ALLOC(ndr, r->out.info);
22135                 } else {
22136                         r->out.info = NULL;
22137                 }
22138                 if (r->out.info) {
22139                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22140                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22141                         {
22142                                 struct ndr_pull *_ndr_info;
22143                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22144                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22145                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22146                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22147                         }
22148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22149                 }
22150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22151                         NDR_PULL_ALLOC(ndr, r->out.needed);
22152                 }
22153                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22154                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22157                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22158         }
22159         return NDR_ERR_SUCCESS;
22160 }
22161
22162 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
22163 {
22164         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
22165         ndr->depth++;
22166         if (flags & NDR_SET_VALUES) {
22167                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22168         }
22169         if (flags & NDR_IN) {
22170                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
22171                 ndr->depth++;
22172                 ndr_print_ptr(ndr, "server", r->in.server);
22173                 ndr->depth++;
22174                 if (r->in.server) {
22175                         ndr_print_string(ndr, "server", r->in.server);
22176                 }
22177                 ndr->depth--;
22178                 ndr_print_ptr(ndr, "environment", r->in.environment);
22179                 ndr->depth++;
22180                 if (r->in.environment) {
22181                         ndr_print_string(ndr, "environment", r->in.environment);
22182                 }
22183                 ndr->depth--;
22184                 ndr_print_uint32(ndr, "level", r->in.level);
22185                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22186                 ndr->depth++;
22187                 if (r->in.buffer) {
22188                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22189                 }
22190                 ndr->depth--;
22191                 ndr_print_uint32(ndr, "offered", r->in.offered);
22192                 ndr->depth--;
22193         }
22194         if (flags & NDR_OUT) {
22195                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
22196                 ndr->depth++;
22197                 ndr_print_ptr(ndr, "info", r->out.info);
22198                 ndr->depth++;
22199                 if (r->out.info) {
22200                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22201                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
22202                 }
22203                 ndr->depth--;
22204                 ndr_print_ptr(ndr, "needed", r->out.needed);
22205                 ndr->depth++;
22206                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22207                 ndr->depth--;
22208                 ndr_print_WERROR(ndr, "result", r->out.result);
22209                 ndr->depth--;
22210         }
22211         ndr->depth--;
22212 }
22213
22214 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
22215 {
22216         if (flags & NDR_IN) {
22217                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22218                 if (r->in.server) {
22219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22222                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22223                 }
22224                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22225                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22226                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22227                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22228                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22229                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22230                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
22231                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22232         }
22233         if (flags & NDR_OUT) {
22234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22235         }
22236         return NDR_ERR_SUCCESS;
22237 }
22238
22239 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
22240 {
22241         uint32_t _ptr_server;
22242         TALLOC_CTX *_mem_save_server_0;
22243         if (flags & NDR_IN) {
22244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22245                 if (_ptr_server) {
22246                         NDR_PULL_ALLOC(ndr, r->in.server);
22247                 } else {
22248                         r->in.server = NULL;
22249                 }
22250                 if (r->in.server) {
22251                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22252                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22255                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22256                                 return 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));
22257                         }
22258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22261                 }
22262                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22263                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22264                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22265                         return 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));
22266                 }
22267                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22268                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22269                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
22270                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
22271                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
22272                         return 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));
22273                 }
22274                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
22275                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
22276         }
22277         if (flags & NDR_OUT) {
22278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22279         }
22280         return NDR_ERR_SUCCESS;
22281 }
22282
22283 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
22284 {
22285         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
22286         ndr->depth++;
22287         if (flags & NDR_SET_VALUES) {
22288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22289         }
22290         if (flags & NDR_IN) {
22291                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
22292                 ndr->depth++;
22293                 ndr_print_ptr(ndr, "server", r->in.server);
22294                 ndr->depth++;
22295                 if (r->in.server) {
22296                         ndr_print_string(ndr, "server", r->in.server);
22297                 }
22298                 ndr->depth--;
22299                 ndr_print_string(ndr, "architecture", r->in.architecture);
22300                 ndr_print_string(ndr, "driver", r->in.driver);
22301                 ndr->depth--;
22302         }
22303         if (flags & NDR_OUT) {
22304                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
22305                 ndr->depth++;
22306                 ndr_print_WERROR(ndr, "result", r->out.result);
22307                 ndr->depth--;
22308         }
22309         ndr->depth--;
22310 }
22311
22312 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
22313 {
22314         if (flags & NDR_IN) {
22315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22316                 if (r->in.server) {
22317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22320                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22321                 }
22322                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22323                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22324                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
22325                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22326                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22327                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22328                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
22329                 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));
22330                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22331                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22332                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
22333                 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));
22334         }
22335         if (flags & NDR_OUT) {
22336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22337         }
22338         return NDR_ERR_SUCCESS;
22339 }
22340
22341 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
22342 {
22343         uint32_t _ptr_server;
22344         TALLOC_CTX *_mem_save_server_0;
22345         if (flags & NDR_IN) {
22346                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22347                 if (_ptr_server) {
22348                         NDR_PULL_ALLOC(ndr, r->in.server);
22349                 } else {
22350                         r->in.server = NULL;
22351                 }
22352                 if (r->in.server) {
22353                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22354                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22357                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22358                                 return 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));
22359                         }
22360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22363                 }
22364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22365                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22366                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22367                         return 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));
22368                 }
22369                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22370                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22371                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
22372                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
22373                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
22374                         return 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));
22375                 }
22376                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
22377                 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));
22378                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
22379                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
22380                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
22381                         return 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));
22382                 }
22383                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
22384                 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));
22385         }
22386         if (flags & NDR_OUT) {
22387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22388         }
22389         return NDR_ERR_SUCCESS;
22390 }
22391
22392 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
22393 {
22394         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
22395         ndr->depth++;
22396         if (flags & NDR_SET_VALUES) {
22397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22398         }
22399         if (flags & NDR_IN) {
22400                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
22401                 ndr->depth++;
22402                 ndr_print_ptr(ndr, "server", r->in.server);
22403                 ndr->depth++;
22404                 if (r->in.server) {
22405                         ndr_print_string(ndr, "server", r->in.server);
22406                 }
22407                 ndr->depth--;
22408                 ndr_print_string(ndr, "architecture", r->in.architecture);
22409                 ndr_print_string(ndr, "path_name", r->in.path_name);
22410                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
22411                 ndr->depth--;
22412         }
22413         if (flags & NDR_OUT) {
22414                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
22415                 ndr->depth++;
22416                 ndr_print_WERROR(ndr, "result", r->out.result);
22417                 ndr->depth--;
22418         }
22419         ndr->depth--;
22420 }
22421
22422 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
22423 {
22424         if (flags & NDR_IN) {
22425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22426                 if (r->in.servername) {
22427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22430                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22431                 }
22432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22433                 if (r->in.environment) {
22434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22436                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22438                 }
22439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22441                 if (r->in.buffer) {
22442                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22443                 }
22444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22445         }
22446         if (flags & NDR_OUT) {
22447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22448                 if (r->out.info) {
22449                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22450                 }
22451                 if (r->out.needed == NULL) {
22452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22453                 }
22454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22455                 if (r->out.count == NULL) {
22456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22457                 }
22458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22459                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22460         }
22461         return NDR_ERR_SUCCESS;
22462 }
22463
22464 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
22465 {
22466         uint32_t _ptr_servername;
22467         uint32_t _ptr_environment;
22468         uint32_t _ptr_buffer;
22469         uint32_t _ptr_info;
22470         TALLOC_CTX *_mem_save_servername_0;
22471         TALLOC_CTX *_mem_save_environment_0;
22472         TALLOC_CTX *_mem_save_buffer_0;
22473         TALLOC_CTX *_mem_save_info_0;
22474         TALLOC_CTX *_mem_save_needed_0;
22475         TALLOC_CTX *_mem_save_count_0;
22476         if (flags & NDR_IN) {
22477                 ZERO_STRUCT(r->out);
22478
22479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22480                 if (_ptr_servername) {
22481                         NDR_PULL_ALLOC(ndr, r->in.servername);
22482                 } else {
22483                         r->in.servername = NULL;
22484                 }
22485                 if (r->in.servername) {
22486                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22487                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22488                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22489                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22490                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22491                                 return 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));
22492                         }
22493                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22494                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22496                 }
22497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22498                 if (_ptr_environment) {
22499                         NDR_PULL_ALLOC(ndr, r->in.environment);
22500                 } else {
22501                         r->in.environment = NULL;
22502                 }
22503                 if (r->in.environment) {
22504                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22505                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22508                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22509                                 return 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));
22510                         }
22511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22514                 }
22515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22517                 if (_ptr_buffer) {
22518                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22519                 } else {
22520                         r->in.buffer = NULL;
22521                 }
22522                 if (r->in.buffer) {
22523                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22525                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22527                 }
22528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22529                 NDR_PULL_ALLOC(ndr, r->out.needed);
22530                 ZERO_STRUCTP(r->out.needed);
22531                 NDR_PULL_ALLOC(ndr, r->out.count);
22532                 ZERO_STRUCTP(r->out.count);
22533         }
22534         if (flags & NDR_OUT) {
22535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22536                 if (_ptr_info) {
22537                         NDR_PULL_ALLOC(ndr, r->out.info);
22538                 } else {
22539                         r->out.info = NULL;
22540                 }
22541                 if (r->out.info) {
22542                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22543                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22544                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22546                 }
22547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22548                         NDR_PULL_ALLOC(ndr, r->out.needed);
22549                 }
22550                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22555                         NDR_PULL_ALLOC(ndr, r->out.count);
22556                 }
22557                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22562         }
22563         return NDR_ERR_SUCCESS;
22564 }
22565
22566 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
22567 {
22568         uint32_t cntr_info_0;
22569         if (flags & NDR_IN) {
22570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22572         }
22573         if (flags & NDR_OUT) {
22574                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22575                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22576                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22577                 }
22578                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22579                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22580                 }
22581         }
22582         return NDR_ERR_SUCCESS;
22583 }
22584
22585 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
22586 {
22587         uint32_t cntr_info_0;
22588         TALLOC_CTX *_mem_save_info_0;
22589         if (flags & NDR_IN) {
22590                 ZERO_STRUCT(r->out);
22591
22592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22594         }
22595         if (flags & NDR_OUT) {
22596                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22597                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22599                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22600                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22601                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22602                 }
22603                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22604                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22605                 }
22606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22607         }
22608         return NDR_ERR_SUCCESS;
22609 }
22610
22611 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
22612 {
22613         uint32_t cntr_info_2;
22614         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
22615         ndr->depth++;
22616         if (flags & NDR_SET_VALUES) {
22617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22618         }
22619         if (flags & NDR_IN) {
22620                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
22621                 ndr->depth++;
22622                 ndr_print_ptr(ndr, "servername", r->in.servername);
22623                 ndr->depth++;
22624                 if (r->in.servername) {
22625                         ndr_print_string(ndr, "servername", r->in.servername);
22626                 }
22627                 ndr->depth--;
22628                 ndr_print_ptr(ndr, "environment", r->in.environment);
22629                 ndr->depth++;
22630                 if (r->in.environment) {
22631                         ndr_print_string(ndr, "environment", r->in.environment);
22632                 }
22633                 ndr->depth--;
22634                 ndr_print_uint32(ndr, "level", r->in.level);
22635                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22636                 ndr->depth++;
22637                 if (r->in.buffer) {
22638                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22639                 }
22640                 ndr->depth--;
22641                 ndr_print_uint32(ndr, "offered", r->in.offered);
22642                 ndr->depth--;
22643         }
22644         if (flags & NDR_OUT) {
22645                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
22646                 ndr->depth++;
22647                 ndr_print_ptr(ndr, "count", r->out.count);
22648                 ndr->depth++;
22649                 ndr_print_uint32(ndr, "count", *r->out.count);
22650                 ndr->depth--;
22651                 ndr_print_ptr(ndr, "info", r->out.info);
22652                 ndr->depth++;
22653                 ndr_print_ptr(ndr, "info", *r->out.info);
22654                 ndr->depth++;
22655                 if (*r->out.info) {
22656                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22657                         ndr->depth++;
22658                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22659                                 char *idx_2=NULL;
22660                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22661                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22662                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22663                                         free(idx_2);
22664                                 }
22665                         }
22666                         ndr->depth--;
22667                 }
22668                 ndr->depth--;
22669                 ndr->depth--;
22670                 ndr_print_ptr(ndr, "needed", r->out.needed);
22671                 ndr->depth++;
22672                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22673                 ndr->depth--;
22674                 ndr_print_WERROR(ndr, "result", r->out.result);
22675                 ndr->depth--;
22676         }
22677         ndr->depth--;
22678 }
22679
22680 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22681 {
22682         if (flags & NDR_IN) {
22683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
22684                 if (r->in.server) {
22685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
22688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22689                 }
22690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
22691                 if (r->in.environment) {
22692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
22694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
22695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22696                 }
22697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22699                 if (r->in.buffer) {
22700                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22701                 }
22702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22703         }
22704         if (flags & NDR_OUT) {
22705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22706                 if (r->out.info) {
22707                         {
22708                                 struct ndr_push *_ndr_info;
22709                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22710                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22711                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22712                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22713                         }
22714                 }
22715                 if (r->out.needed == NULL) {
22716                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22717                 }
22718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22719                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22720         }
22721         return NDR_ERR_SUCCESS;
22722 }
22723
22724 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
22725 {
22726         uint32_t _ptr_server;
22727         uint32_t _ptr_environment;
22728         uint32_t _ptr_buffer;
22729         uint32_t _ptr_info;
22730         TALLOC_CTX *_mem_save_server_0;
22731         TALLOC_CTX *_mem_save_environment_0;
22732         TALLOC_CTX *_mem_save_buffer_0;
22733         TALLOC_CTX *_mem_save_info_0;
22734         TALLOC_CTX *_mem_save_needed_0;
22735         if (flags & NDR_IN) {
22736                 ZERO_STRUCT(r->out);
22737
22738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
22739                 if (_ptr_server) {
22740                         NDR_PULL_ALLOC(ndr, r->in.server);
22741                 } else {
22742                         r->in.server = NULL;
22743                 }
22744                 if (r->in.server) {
22745                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
22746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
22747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
22748                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
22749                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
22750                                 return 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));
22751                         }
22752                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
22753                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
22754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
22755                 }
22756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
22757                 if (_ptr_environment) {
22758                         NDR_PULL_ALLOC(ndr, r->in.environment);
22759                 } else {
22760                         r->in.environment = NULL;
22761                 }
22762                 if (r->in.environment) {
22763                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
22764                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
22765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
22766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
22767                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
22768                                 return 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));
22769                         }
22770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
22771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
22772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
22773                 }
22774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22776                 if (_ptr_buffer) {
22777                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22778                 } else {
22779                         r->in.buffer = NULL;
22780                 }
22781                 if (r->in.buffer) {
22782                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22783                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22784                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22786                 }
22787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22788                 NDR_PULL_ALLOC(ndr, r->out.needed);
22789                 ZERO_STRUCTP(r->out.needed);
22790         }
22791         if (flags & NDR_OUT) {
22792                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22793                 if (_ptr_info) {
22794                         NDR_PULL_ALLOC(ndr, r->out.info);
22795                 } else {
22796                         r->out.info = NULL;
22797                 }
22798                 if (r->out.info) {
22799                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22800                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22801                         {
22802                                 struct ndr_pull *_ndr_info;
22803                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22804                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22805                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
22806                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22807                         }
22808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22809                 }
22810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22811                         NDR_PULL_ALLOC(ndr, r->out.needed);
22812                 }
22813                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22817                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22818         }
22819         return NDR_ERR_SUCCESS;
22820 }
22821
22822 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
22823 {
22824         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
22825         ndr->depth++;
22826         if (flags & NDR_SET_VALUES) {
22827                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22828         }
22829         if (flags & NDR_IN) {
22830                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
22831                 ndr->depth++;
22832                 ndr_print_ptr(ndr, "server", r->in.server);
22833                 ndr->depth++;
22834                 if (r->in.server) {
22835                         ndr_print_string(ndr, "server", r->in.server);
22836                 }
22837                 ndr->depth--;
22838                 ndr_print_ptr(ndr, "environment", r->in.environment);
22839                 ndr->depth++;
22840                 if (r->in.environment) {
22841                         ndr_print_string(ndr, "environment", r->in.environment);
22842                 }
22843                 ndr->depth--;
22844                 ndr_print_uint32(ndr, "level", r->in.level);
22845                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22846                 ndr->depth++;
22847                 if (r->in.buffer) {
22848                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22849                 }
22850                 ndr->depth--;
22851                 ndr_print_uint32(ndr, "offered", r->in.offered);
22852                 ndr->depth--;
22853         }
22854         if (flags & NDR_OUT) {
22855                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
22856                 ndr->depth++;
22857                 ndr_print_ptr(ndr, "info", r->out.info);
22858                 ndr->depth++;
22859                 if (r->out.info) {
22860                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22861                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
22862                 }
22863                 ndr->depth--;
22864                 ndr_print_ptr(ndr, "needed", r->out.needed);
22865                 ndr->depth++;
22866                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22867                 ndr->depth--;
22868                 ndr_print_WERROR(ndr, "result", r->out.result);
22869                 ndr->depth--;
22870         }
22871         ndr->depth--;
22872 }
22873
22874 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
22875 {
22876         if (flags & NDR_IN) {
22877                 if (r->in.handle == NULL) {
22878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22879                 }
22880                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22882                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22883                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22884         }
22885         if (flags & NDR_OUT) {
22886                 if (r->out.job_id == NULL) {
22887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22888                 }
22889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
22890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22891         }
22892         return NDR_ERR_SUCCESS;
22893 }
22894
22895 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
22896 {
22897         TALLOC_CTX *_mem_save_handle_0;
22898         TALLOC_CTX *_mem_save_job_id_0;
22899         if (flags & NDR_IN) {
22900                 ZERO_STRUCT(r->out);
22901
22902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22903                         NDR_PULL_ALLOC(ndr, r->in.handle);
22904                 }
22905                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22906                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22907                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22910                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22911                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22912                 NDR_PULL_ALLOC(ndr, r->out.job_id);
22913                 ZERO_STRUCTP(r->out.job_id);
22914         }
22915         if (flags & NDR_OUT) {
22916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22917                         NDR_PULL_ALLOC(ndr, r->out.job_id);
22918                 }
22919                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
22920                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
22921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
22922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
22923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22924         }
22925         return NDR_ERR_SUCCESS;
22926 }
22927
22928 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
22929 {
22930         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
22931         ndr->depth++;
22932         if (flags & NDR_SET_VALUES) {
22933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22934         }
22935         if (flags & NDR_IN) {
22936                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
22937                 ndr->depth++;
22938                 ndr_print_ptr(ndr, "handle", r->in.handle);
22939                 ndr->depth++;
22940                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22941                 ndr->depth--;
22942                 ndr_print_uint32(ndr, "level", r->in.level);
22943                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22944                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
22945                 ndr->depth--;
22946         }
22947         if (flags & NDR_OUT) {
22948                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
22949                 ndr->depth++;
22950                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
22951                 ndr->depth++;
22952                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
22953                 ndr->depth--;
22954                 ndr_print_WERROR(ndr, "result", r->out.result);
22955                 ndr->depth--;
22956         }
22957         ndr->depth--;
22958 }
22959
22960 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
22961 {
22962         if (flags & NDR_IN) {
22963                 if (r->in.handle == NULL) {
22964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22965                 }
22966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22967         }
22968         if (flags & NDR_OUT) {
22969                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22970         }
22971         return NDR_ERR_SUCCESS;
22972 }
22973
22974 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
22975 {
22976         TALLOC_CTX *_mem_save_handle_0;
22977         if (flags & NDR_IN) {
22978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22979                         NDR_PULL_ALLOC(ndr, r->in.handle);
22980                 }
22981                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22982                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22983                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22985         }
22986         if (flags & NDR_OUT) {
22987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22988         }
22989         return NDR_ERR_SUCCESS;
22990 }
22991
22992 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
22993 {
22994         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
22995         ndr->depth++;
22996         if (flags & NDR_SET_VALUES) {
22997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22998         }
22999         if (flags & NDR_IN) {
23000                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
23001                 ndr->depth++;
23002                 ndr_print_ptr(ndr, "handle", r->in.handle);
23003                 ndr->depth++;
23004                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23005                 ndr->depth--;
23006                 ndr->depth--;
23007         }
23008         if (flags & NDR_OUT) {
23009                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
23010                 ndr->depth++;
23011                 ndr_print_WERROR(ndr, "result", r->out.result);
23012                 ndr->depth--;
23013         }
23014         ndr->depth--;
23015 }
23016
23017 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
23018 {
23019         if (flags & NDR_IN) {
23020                 if (r->in.handle == NULL) {
23021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23022                 }
23023                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23024                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
23026         }
23027         if (flags & NDR_OUT) {
23028                 if (r->out.num_written == NULL) {
23029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23030                 }
23031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
23032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23033         }
23034         return NDR_ERR_SUCCESS;
23035 }
23036
23037 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
23038 {
23039         TALLOC_CTX *_mem_save_handle_0;
23040         TALLOC_CTX *_mem_save_num_written_0;
23041         if (flags & NDR_IN) {
23042                 ZERO_STRUCT(r->out);
23043
23044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23045                         NDR_PULL_ALLOC(ndr, r->in.handle);
23046                 }
23047                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23048                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23049                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23050                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23051                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
23052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
23053                 NDR_PULL_ALLOC(ndr, r->out.num_written);
23054                 ZERO_STRUCTP(r->out.num_written);
23055         }
23056         if (flags & NDR_OUT) {
23057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23058                         NDR_PULL_ALLOC(ndr, r->out.num_written);
23059                 }
23060                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
23061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
23062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
23063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
23064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23065         }
23066         return NDR_ERR_SUCCESS;
23067 }
23068
23069 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
23070 {
23071         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
23072         ndr->depth++;
23073         if (flags & NDR_SET_VALUES) {
23074                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23075         }
23076         if (flags & NDR_IN) {
23077                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
23078                 ndr->depth++;
23079                 ndr_print_ptr(ndr, "handle", r->in.handle);
23080                 ndr->depth++;
23081                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23082                 ndr->depth--;
23083                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
23084                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
23085                 ndr->depth--;
23086         }
23087         if (flags & NDR_OUT) {
23088                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
23089                 ndr->depth++;
23090                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
23091                 ndr->depth++;
23092                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
23093                 ndr->depth--;
23094                 ndr_print_WERROR(ndr, "result", r->out.result);
23095                 ndr->depth--;
23096         }
23097         ndr->depth--;
23098 }
23099
23100 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
23101 {
23102         if (flags & NDR_IN) {
23103                 if (r->in.handle == NULL) {
23104                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23105                 }
23106                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23107         }
23108         if (flags & NDR_OUT) {
23109                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23110         }
23111         return NDR_ERR_SUCCESS;
23112 }
23113
23114 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
23115 {
23116         TALLOC_CTX *_mem_save_handle_0;
23117         if (flags & NDR_IN) {
23118                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23119                         NDR_PULL_ALLOC(ndr, r->in.handle);
23120                 }
23121                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23122                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23123                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23125         }
23126         if (flags & NDR_OUT) {
23127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23128         }
23129         return NDR_ERR_SUCCESS;
23130 }
23131
23132 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
23133 {
23134         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
23135         ndr->depth++;
23136         if (flags & NDR_SET_VALUES) {
23137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23138         }
23139         if (flags & NDR_IN) {
23140                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
23141                 ndr->depth++;
23142                 ndr_print_ptr(ndr, "handle", r->in.handle);
23143                 ndr->depth++;
23144                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23145                 ndr->depth--;
23146                 ndr->depth--;
23147         }
23148         if (flags & NDR_OUT) {
23149                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
23150                 ndr->depth++;
23151                 ndr_print_WERROR(ndr, "result", r->out.result);
23152                 ndr->depth--;
23153         }
23154         ndr->depth--;
23155 }
23156
23157 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
23158 {
23159         if (flags & NDR_IN) {
23160                 if (r->in.handle == NULL) {
23161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23162                 }
23163                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23164         }
23165         if (flags & NDR_OUT) {
23166                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23167         }
23168         return NDR_ERR_SUCCESS;
23169 }
23170
23171 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
23172 {
23173         TALLOC_CTX *_mem_save_handle_0;
23174         if (flags & NDR_IN) {
23175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23176                         NDR_PULL_ALLOC(ndr, r->in.handle);
23177                 }
23178                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23179                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23180                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23182         }
23183         if (flags & NDR_OUT) {
23184                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23185         }
23186         return NDR_ERR_SUCCESS;
23187 }
23188
23189 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
23190 {
23191         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
23192         ndr->depth++;
23193         if (flags & NDR_SET_VALUES) {
23194                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23195         }
23196         if (flags & NDR_IN) {
23197                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
23198                 ndr->depth++;
23199                 ndr_print_ptr(ndr, "handle", r->in.handle);
23200                 ndr->depth++;
23201                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23202                 ndr->depth--;
23203                 ndr->depth--;
23204         }
23205         if (flags & NDR_OUT) {
23206                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
23207                 ndr->depth++;
23208                 ndr_print_WERROR(ndr, "result", r->out.result);
23209                 ndr->depth--;
23210         }
23211         ndr->depth--;
23212 }
23213
23214 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
23215 {
23216         if (flags & NDR_IN) {
23217                 if (r->in.handle == NULL) {
23218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23219                 }
23220                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23221                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
23222         }
23223         if (flags & NDR_OUT) {
23224                 if (r->out.data == NULL) {
23225                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23226                 }
23227                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_size));
23228                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
23229                 if (r->out._data_size == NULL) {
23230                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23231                 }
23232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
23233                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23234         }
23235         return NDR_ERR_SUCCESS;
23236 }
23237
23238 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
23239 {
23240         TALLOC_CTX *_mem_save_handle_0;
23241         TALLOC_CTX *_mem_save__data_size_0;
23242         if (flags & NDR_IN) {
23243                 ZERO_STRUCT(r->out);
23244
23245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23246                         NDR_PULL_ALLOC(ndr, r->in.handle);
23247                 }
23248                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
23253                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
23254                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
23255                 NDR_PULL_ALLOC(ndr, r->out._data_size);
23256                 ZERO_STRUCTP(r->out._data_size);
23257         }
23258         if (flags & NDR_OUT) {
23259                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
23260                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23261                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
23262                 }
23263                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
23264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23265                         NDR_PULL_ALLOC(ndr, r->out._data_size);
23266                 }
23267                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
23268                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
23269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
23270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
23271                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23272                 if (r->out.data) {
23273                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
23274                 }
23275         }
23276         return NDR_ERR_SUCCESS;
23277 }
23278
23279 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
23280 {
23281         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
23282         ndr->depth++;
23283         if (flags & NDR_SET_VALUES) {
23284                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23285         }
23286         if (flags & NDR_IN) {
23287                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
23288                 ndr->depth++;
23289                 ndr_print_ptr(ndr, "handle", r->in.handle);
23290                 ndr->depth++;
23291                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23292                 ndr->depth--;
23293                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
23294                 ndr->depth--;
23295         }
23296         if (flags & NDR_OUT) {
23297                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
23298                 ndr->depth++;
23299                 ndr_print_ptr(ndr, "data", r->out.data);
23300                 ndr->depth++;
23301                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
23302                 ndr->depth--;
23303                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
23304                 ndr->depth++;
23305                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
23306                 ndr->depth--;
23307                 ndr_print_WERROR(ndr, "result", r->out.result);
23308                 ndr->depth--;
23309         }
23310         ndr->depth--;
23311 }
23312
23313 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
23314 {
23315         if (flags & NDR_IN) {
23316                 if (r->in.handle == NULL) {
23317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23318                 }
23319                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23320         }
23321         if (flags & NDR_OUT) {
23322                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23323         }
23324         return NDR_ERR_SUCCESS;
23325 }
23326
23327 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
23328 {
23329         TALLOC_CTX *_mem_save_handle_0;
23330         if (flags & NDR_IN) {
23331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23332                         NDR_PULL_ALLOC(ndr, r->in.handle);
23333                 }
23334                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23335                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23336                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23338         }
23339         if (flags & NDR_OUT) {
23340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23341         }
23342         return NDR_ERR_SUCCESS;
23343 }
23344
23345 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
23346 {
23347         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
23348         ndr->depth++;
23349         if (flags & NDR_SET_VALUES) {
23350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23351         }
23352         if (flags & NDR_IN) {
23353                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
23354                 ndr->depth++;
23355                 ndr_print_ptr(ndr, "handle", r->in.handle);
23356                 ndr->depth++;
23357                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23358                 ndr->depth--;
23359                 ndr->depth--;
23360         }
23361         if (flags & NDR_OUT) {
23362                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
23363                 ndr->depth++;
23364                 ndr_print_WERROR(ndr, "result", r->out.result);
23365                 ndr->depth--;
23366         }
23367         ndr->depth--;
23368 }
23369
23370 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
23371 {
23372         if (flags & NDR_IN) {
23373                 if (r->in.handle == NULL) {
23374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23375                 }
23376                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23378                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23379                 if (r->in.buffer) {
23380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23381                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23382                 }
23383                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23384         }
23385         if (flags & NDR_OUT) {
23386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
23387                 if (r->out.buffer) {
23388                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.offered));
23389                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23390                 }
23391                 if (r->out.needed == NULL) {
23392                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23393                 }
23394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23395                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23396         }
23397         return NDR_ERR_SUCCESS;
23398 }
23399
23400 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
23401 {
23402         uint32_t _ptr_buffer;
23403         TALLOC_CTX *_mem_save_handle_0;
23404         TALLOC_CTX *_mem_save_buffer_0;
23405         TALLOC_CTX *_mem_save_needed_0;
23406         if (flags & NDR_IN) {
23407                 ZERO_STRUCT(r->out);
23408
23409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23410                         NDR_PULL_ALLOC(ndr, r->in.handle);
23411                 }
23412                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23414                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23418                 if (_ptr_buffer) {
23419                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23420                 } else {
23421                         r->in.buffer = NULL;
23422                 }
23423                 if (r->in.buffer) {
23424                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23425                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23426                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23427                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23428                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23430                 }
23431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23432                 NDR_PULL_ALLOC(ndr, r->out.needed);
23433                 ZERO_STRUCTP(r->out.needed);
23434                 if (r->in.buffer) {
23435                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23436                 }
23437         }
23438         if (flags & NDR_OUT) {
23439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23440                 if (_ptr_buffer) {
23441                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23442                 } else {
23443                         r->out.buffer = NULL;
23444                 }
23445                 if (r->out.buffer) {
23446                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23447                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
23448                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
23449                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
23450                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
23451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23452                 }
23453                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23454                         NDR_PULL_ALLOC(ndr, r->out.needed);
23455                 }
23456                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23457                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23459                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23461                 if (r->out.buffer) {
23462                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
23463                 }
23464         }
23465         return NDR_ERR_SUCCESS;
23466 }
23467
23468 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
23469 {
23470         ndr_print_struct(ndr, name, "spoolss_AddJob");
23471         ndr->depth++;
23472         if (flags & NDR_SET_VALUES) {
23473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23474         }
23475         if (flags & NDR_IN) {
23476                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
23477                 ndr->depth++;
23478                 ndr_print_ptr(ndr, "handle", r->in.handle);
23479                 ndr->depth++;
23480                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23481                 ndr->depth--;
23482                 ndr_print_uint32(ndr, "level", r->in.level);
23483                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23484                 ndr->depth++;
23485                 if (r->in.buffer) {
23486                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23487                 }
23488                 ndr->depth--;
23489                 ndr_print_uint32(ndr, "offered", r->in.offered);
23490                 ndr->depth--;
23491         }
23492         if (flags & NDR_OUT) {
23493                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
23494                 ndr->depth++;
23495                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23496                 ndr->depth++;
23497                 if (r->out.buffer) {
23498                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
23499                 }
23500                 ndr->depth--;
23501                 ndr_print_ptr(ndr, "needed", r->out.needed);
23502                 ndr->depth++;
23503                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23504                 ndr->depth--;
23505                 ndr_print_WERROR(ndr, "result", r->out.result);
23506                 ndr->depth--;
23507         }
23508         ndr->depth--;
23509 }
23510
23511 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
23512 {
23513         if (flags & NDR_IN) {
23514                 if (r->in.handle == NULL) {
23515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23516                 }
23517                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
23519         }
23520         if (flags & NDR_OUT) {
23521                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23522         }
23523         return NDR_ERR_SUCCESS;
23524 }
23525
23526 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
23527 {
23528         TALLOC_CTX *_mem_save_handle_0;
23529         if (flags & NDR_IN) {
23530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23531                         NDR_PULL_ALLOC(ndr, r->in.handle);
23532                 }
23533                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23534                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23535                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
23538         }
23539         if (flags & NDR_OUT) {
23540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23541         }
23542         return NDR_ERR_SUCCESS;
23543 }
23544
23545 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
23546 {
23547         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
23548         ndr->depth++;
23549         if (flags & NDR_SET_VALUES) {
23550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23551         }
23552         if (flags & NDR_IN) {
23553                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
23554                 ndr->depth++;
23555                 ndr_print_ptr(ndr, "handle", r->in.handle);
23556                 ndr->depth++;
23557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23558                 ndr->depth--;
23559                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
23560                 ndr->depth--;
23561         }
23562         if (flags & NDR_OUT) {
23563                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
23564                 ndr->depth++;
23565                 ndr_print_WERROR(ndr, "result", r->out.result);
23566                 ndr->depth--;
23567         }
23568         ndr->depth--;
23569 }
23570
23571 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
23572 {
23573         if (flags & NDR_IN) {
23574                 if (r->in.handle == NULL) {
23575                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23576                 }
23577                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23578                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23579                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23580                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23581                 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));
23582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23583         }
23584         if (flags & NDR_OUT) {
23585                 if (r->out.type == NULL) {
23586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23587                 }
23588                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
23589                 if (r->out.data == NULL) {
23590                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23591                 }
23592                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
23593                 if (r->out.needed == NULL) {
23594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23595                 }
23596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23598         }
23599         return NDR_ERR_SUCCESS;
23600 }
23601
23602 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
23603 {
23604         TALLOC_CTX *_mem_save_handle_0;
23605         TALLOC_CTX *_mem_save_type_0;
23606         TALLOC_CTX *_mem_save_data_0;
23607         TALLOC_CTX *_mem_save_needed_0;
23608         if (flags & NDR_IN) {
23609                 ZERO_STRUCT(r->out);
23610
23611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23612                         NDR_PULL_ALLOC(ndr, r->in.handle);
23613                 }
23614                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23615                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23616                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23618                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23619                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23620                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23621                         return 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));
23622                 }
23623                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23624                 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));
23625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23626                 NDR_PULL_ALLOC(ndr, r->out.type);
23627                 ZERO_STRUCTP(r->out.type);
23628                 NDR_PULL_ALLOC(ndr, r->out.data);
23629                 ZERO_STRUCTP(r->out.data);
23630                 NDR_PULL_ALLOC(ndr, r->out.needed);
23631                 ZERO_STRUCTP(r->out.needed);
23632         }
23633         if (flags & NDR_OUT) {
23634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23635                         NDR_PULL_ALLOC(ndr, r->out.type);
23636                 }
23637                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
23639                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
23640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
23641                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23642                         NDR_PULL_ALLOC(ndr, r->out.data);
23643                 }
23644                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23645                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23646                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
23647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23648                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23649                         NDR_PULL_ALLOC(ndr, r->out.needed);
23650                 }
23651                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23652                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23655                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23656         }
23657         return NDR_ERR_SUCCESS;
23658 }
23659
23660 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
23661 {
23662         if (flags & NDR_IN) {
23663                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23664         }
23665         if (flags & NDR_OUT) {
23666                 if (r->out.data == NULL) {
23667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23668                 }
23669                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23670                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23671         }
23672         return NDR_ERR_SUCCESS;
23673 }
23674
23675 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
23676 {
23677         TALLOC_CTX *_mem_save_data_0;
23678         if (flags & NDR_IN) {
23679                 ZERO_STRUCT(r->out);
23680
23681                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23682                 NDR_PULL_ALLOC(ndr, r->out.data);
23683                 ZERO_STRUCTP(r->out.data);
23684         }
23685         if (flags & NDR_OUT) {
23686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23687                         NDR_PULL_ALLOC(ndr, r->out.data);
23688                 }
23689                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
23690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
23691                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
23692                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
23694         }
23695         return NDR_ERR_SUCCESS;
23696 }
23697
23698 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
23699 {
23700         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
23701         ndr->depth++;
23702         if (flags & NDR_SET_VALUES) {
23703                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23704         }
23705         if (flags & NDR_IN) {
23706                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
23707                 ndr->depth++;
23708                 ndr_print_ptr(ndr, "handle", r->in.handle);
23709                 ndr->depth++;
23710                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23711                 ndr->depth--;
23712                 ndr_print_string(ndr, "value_name", r->in.value_name);
23713                 ndr_print_uint32(ndr, "offered", r->in.offered);
23714                 ndr->depth--;
23715         }
23716         if (flags & NDR_OUT) {
23717                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
23718                 ndr->depth++;
23719                 ndr_print_ptr(ndr, "type", r->out.type);
23720                 ndr->depth++;
23721                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
23722                 ndr->depth--;
23723                 ndr_print_ptr(ndr, "data", r->out.data);
23724                 ndr->depth++;
23725                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
23726                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
23727                 ndr->depth--;
23728                 ndr_print_ptr(ndr, "needed", r->out.needed);
23729                 ndr->depth++;
23730                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23731                 ndr->depth--;
23732                 ndr_print_WERROR(ndr, "result", r->out.result);
23733                 ndr->depth--;
23734         }
23735         ndr->depth--;
23736 }
23737
23738 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
23739 {
23740         if (flags & NDR_IN) {
23741                 if (r->in.handle == NULL) {
23742                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23743                 }
23744                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23745                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23746                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
23747                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23748                 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));
23749                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23750                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
23751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
23752         }
23753         if (flags & NDR_OUT) {
23754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23755         }
23756         return NDR_ERR_SUCCESS;
23757 }
23758
23759 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
23760 {
23761         if (flags & NDR_IN) {
23762                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
23763         }
23764         if (flags & NDR_OUT) {
23765                 if (r->out.data == NULL) {
23766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23767                 }
23768                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
23769                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
23770         }
23771         return NDR_ERR_SUCCESS;
23772 }
23773
23774 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
23775 {
23776         TALLOC_CTX *_mem_save_handle_0;
23777         if (flags & NDR_IN) {
23778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23779                         NDR_PULL_ALLOC(ndr, r->in.handle);
23780                 }
23781                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23782                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23783                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23784                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23785                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23786                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23787                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23788                         return 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));
23789                 }
23790                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23791                 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));
23792                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
23793                 {
23794                         struct ndr_pull *_ndr_data;
23795                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
23796                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
23797                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
23798                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
23799                 }
23800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
23801         }
23802         if (flags & NDR_OUT) {
23803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23804         }
23805         return NDR_ERR_SUCCESS;
23806 }
23807
23808 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
23809 {
23810         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
23811         ndr->depth++;
23812         if (flags & NDR_SET_VALUES) {
23813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23814         }
23815         if (flags & NDR_IN) {
23816                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
23817                 ndr->depth++;
23818                 ndr_print_ptr(ndr, "handle", r->in.handle);
23819                 ndr->depth++;
23820                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23821                 ndr->depth--;
23822                 ndr_print_string(ndr, "value_name", r->in.value_name);
23823                 ndr_print_winreg_Type(ndr, "type", r->in.type);
23824                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
23825                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
23826                 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);
23827                 ndr->depth--;
23828         }
23829         if (flags & NDR_OUT) {
23830                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
23831                 ndr->depth++;
23832                 ndr_print_WERROR(ndr, "result", r->out.result);
23833                 ndr->depth--;
23834         }
23835         ndr->depth--;
23836 }
23837
23838 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
23839 {
23840         if (flags & NDR_IN) {
23841         }
23842         if (flags & NDR_OUT) {
23843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23844         }
23845         return NDR_ERR_SUCCESS;
23846 }
23847
23848 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
23849 {
23850         if (flags & NDR_IN) {
23851         }
23852         if (flags & NDR_OUT) {
23853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23854         }
23855         return NDR_ERR_SUCCESS;
23856 }
23857
23858 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
23859 {
23860         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
23861         ndr->depth++;
23862         if (flags & NDR_SET_VALUES) {
23863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23864         }
23865         if (flags & NDR_IN) {
23866                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
23867                 ndr->depth++;
23868                 ndr->depth--;
23869         }
23870         if (flags & NDR_OUT) {
23871                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
23872                 ndr->depth++;
23873                 ndr_print_WERROR(ndr, "result", r->out.result);
23874                 ndr->depth--;
23875         }
23876         ndr->depth--;
23877 }
23878
23879 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
23880 {
23881         if (flags & NDR_IN) {
23882                 if (r->in.handle == NULL) {
23883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23884                 }
23885                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23886         }
23887         if (flags & NDR_OUT) {
23888                 if (r->out.handle == NULL) {
23889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23890                 }
23891                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23892                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23893         }
23894         return NDR_ERR_SUCCESS;
23895 }
23896
23897 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
23898 {
23899         TALLOC_CTX *_mem_save_handle_0;
23900         if (flags & NDR_IN) {
23901                 ZERO_STRUCT(r->out);
23902
23903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23904                         NDR_PULL_ALLOC(ndr, r->in.handle);
23905                 }
23906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23907                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23910                 NDR_PULL_ALLOC(ndr, r->out.handle);
23911                 *r->out.handle = *r->in.handle;
23912         }
23913         if (flags & NDR_OUT) {
23914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23915                         NDR_PULL_ALLOC(ndr, r->out.handle);
23916                 }
23917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23921                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23922         }
23923         return NDR_ERR_SUCCESS;
23924 }
23925
23926 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
23927 {
23928         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
23929         ndr->depth++;
23930         if (flags & NDR_SET_VALUES) {
23931                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23932         }
23933         if (flags & NDR_IN) {
23934                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
23935                 ndr->depth++;
23936                 ndr_print_ptr(ndr, "handle", r->in.handle);
23937                 ndr->depth++;
23938                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23939                 ndr->depth--;
23940                 ndr->depth--;
23941         }
23942         if (flags & NDR_OUT) {
23943                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
23944                 ndr->depth++;
23945                 ndr_print_ptr(ndr, "handle", r->out.handle);
23946                 ndr->depth++;
23947                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23948                 ndr->depth--;
23949                 ndr_print_WERROR(ndr, "result", r->out.result);
23950                 ndr->depth--;
23951         }
23952         ndr->depth--;
23953 }
23954
23955 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
23956 {
23957         if (flags & NDR_IN) {
23958                 if (r->in.handle == NULL) {
23959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23960                 }
23961                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23963                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
23964                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23965         }
23966         if (flags & NDR_OUT) {
23967                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23968         }
23969         return NDR_ERR_SUCCESS;
23970 }
23971
23972 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
23973 {
23974         TALLOC_CTX *_mem_save_handle_0;
23975         if (flags & NDR_IN) {
23976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23977                         NDR_PULL_ALLOC(ndr, r->in.handle);
23978                 }
23979                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23980                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23981                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23982                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23984                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
23985                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
23986         }
23987         if (flags & NDR_OUT) {
23988                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23989         }
23990         return NDR_ERR_SUCCESS;
23991 }
23992
23993 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
23994 {
23995         ndr_print_struct(ndr, name, "spoolss_AddForm");
23996         ndr->depth++;
23997         if (flags & NDR_SET_VALUES) {
23998                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23999         }
24000         if (flags & NDR_IN) {
24001                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
24002                 ndr->depth++;
24003                 ndr_print_ptr(ndr, "handle", r->in.handle);
24004                 ndr->depth++;
24005                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24006                 ndr->depth--;
24007                 ndr_print_uint32(ndr, "level", r->in.level);
24008                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24009                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24010                 ndr->depth--;
24011         }
24012         if (flags & NDR_OUT) {
24013                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
24014                 ndr->depth++;
24015                 ndr_print_WERROR(ndr, "result", r->out.result);
24016                 ndr->depth--;
24017         }
24018         ndr->depth--;
24019 }
24020
24021 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
24022 {
24023         if (flags & NDR_IN) {
24024                 if (r->in.handle == NULL) {
24025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24026                 }
24027                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24028                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24029                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24030                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24031                 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));
24032         }
24033         if (flags & NDR_OUT) {
24034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24035         }
24036         return NDR_ERR_SUCCESS;
24037 }
24038
24039 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
24040 {
24041         TALLOC_CTX *_mem_save_handle_0;
24042         if (flags & NDR_IN) {
24043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24044                         NDR_PULL_ALLOC(ndr, r->in.handle);
24045                 }
24046                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24047                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24048                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24050                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24051                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24052                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24053                         return 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));
24054                 }
24055                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24056                 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));
24057         }
24058         if (flags & NDR_OUT) {
24059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24060         }
24061         return NDR_ERR_SUCCESS;
24062 }
24063
24064 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
24065 {
24066         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
24067         ndr->depth++;
24068         if (flags & NDR_SET_VALUES) {
24069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24070         }
24071         if (flags & NDR_IN) {
24072                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
24073                 ndr->depth++;
24074                 ndr_print_ptr(ndr, "handle", r->in.handle);
24075                 ndr->depth++;
24076                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24077                 ndr->depth--;
24078                 ndr_print_string(ndr, "form_name", r->in.form_name);
24079                 ndr->depth--;
24080         }
24081         if (flags & NDR_OUT) {
24082                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
24083                 ndr->depth++;
24084                 ndr_print_WERROR(ndr, "result", r->out.result);
24085                 ndr->depth--;
24086         }
24087         ndr->depth--;
24088 }
24089
24090 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
24091 {
24092         if (flags & NDR_IN) {
24093                 if (r->in.handle == NULL) {
24094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24095                 }
24096                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24098                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24099                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24100                 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));
24101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24103                 if (r->in.buffer) {
24104                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24105                 }
24106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24107         }
24108         if (flags & NDR_OUT) {
24109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24110                 if (r->out.info) {
24111                         {
24112                                 struct ndr_push *_ndr_info;
24113                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24114                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24115                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24116                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24117                         }
24118                 }
24119                 if (r->out.needed == NULL) {
24120                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24121                 }
24122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24123                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24124         }
24125         return NDR_ERR_SUCCESS;
24126 }
24127
24128 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
24129 {
24130         uint32_t _ptr_buffer;
24131         uint32_t _ptr_info;
24132         TALLOC_CTX *_mem_save_handle_0;
24133         TALLOC_CTX *_mem_save_buffer_0;
24134         TALLOC_CTX *_mem_save_info_0;
24135         TALLOC_CTX *_mem_save_needed_0;
24136         if (flags & NDR_IN) {
24137                 ZERO_STRUCT(r->out);
24138
24139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24140                         NDR_PULL_ALLOC(ndr, r->in.handle);
24141                 }
24142                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24144                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24146                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24147                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24148                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24149                         return 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));
24150                 }
24151                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24152                 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));
24153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24155                 if (_ptr_buffer) {
24156                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24157                 } else {
24158                         r->in.buffer = NULL;
24159                 }
24160                 if (r->in.buffer) {
24161                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24162                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24163                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24164                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24165                 }
24166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24167                 NDR_PULL_ALLOC(ndr, r->out.needed);
24168                 ZERO_STRUCTP(r->out.needed);
24169         }
24170         if (flags & NDR_OUT) {
24171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24172                 if (_ptr_info) {
24173                         NDR_PULL_ALLOC(ndr, r->out.info);
24174                 } else {
24175                         r->out.info = NULL;
24176                 }
24177                 if (r->out.info) {
24178                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24179                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24180                         {
24181                                 struct ndr_pull *_ndr_info;
24182                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24183                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24184                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24185                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24186                         }
24187                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24188                 }
24189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24190                         NDR_PULL_ALLOC(ndr, r->out.needed);
24191                 }
24192                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24197         }
24198         return NDR_ERR_SUCCESS;
24199 }
24200
24201 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
24202 {
24203         ndr_print_struct(ndr, name, "spoolss_GetForm");
24204         ndr->depth++;
24205         if (flags & NDR_SET_VALUES) {
24206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24207         }
24208         if (flags & NDR_IN) {
24209                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
24210                 ndr->depth++;
24211                 ndr_print_ptr(ndr, "handle", r->in.handle);
24212                 ndr->depth++;
24213                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24214                 ndr->depth--;
24215                 ndr_print_string(ndr, "form_name", r->in.form_name);
24216                 ndr_print_uint32(ndr, "level", r->in.level);
24217                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24218                 ndr->depth++;
24219                 if (r->in.buffer) {
24220                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24221                 }
24222                 ndr->depth--;
24223                 ndr_print_uint32(ndr, "offered", r->in.offered);
24224                 ndr->depth--;
24225         }
24226         if (flags & NDR_OUT) {
24227                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
24228                 ndr->depth++;
24229                 ndr_print_ptr(ndr, "info", r->out.info);
24230                 ndr->depth++;
24231                 if (r->out.info) {
24232                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24233                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
24234                 }
24235                 ndr->depth--;
24236                 ndr_print_ptr(ndr, "needed", r->out.needed);
24237                 ndr->depth++;
24238                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24239                 ndr->depth--;
24240                 ndr_print_WERROR(ndr, "result", r->out.result);
24241                 ndr->depth--;
24242         }
24243         ndr->depth--;
24244 }
24245
24246 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
24247 {
24248         if (flags & NDR_IN) {
24249                 if (r->in.handle == NULL) {
24250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24251                 }
24252                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24253                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24254                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24255                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
24256                 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));
24257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24258                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
24259                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24260         }
24261         if (flags & NDR_OUT) {
24262                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24263         }
24264         return NDR_ERR_SUCCESS;
24265 }
24266
24267 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
24268 {
24269         TALLOC_CTX *_mem_save_handle_0;
24270         if (flags & NDR_IN) {
24271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24272                         NDR_PULL_ALLOC(ndr, r->in.handle);
24273                 }
24274                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24275                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24276                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24278                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
24279                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
24280                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
24281                         return 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));
24282                 }
24283                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
24284                 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));
24285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24286                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
24287                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24288         }
24289         if (flags & NDR_OUT) {
24290                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24291         }
24292         return NDR_ERR_SUCCESS;
24293 }
24294
24295 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
24296 {
24297         ndr_print_struct(ndr, name, "spoolss_SetForm");
24298         ndr->depth++;
24299         if (flags & NDR_SET_VALUES) {
24300                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24301         }
24302         if (flags & NDR_IN) {
24303                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
24304                 ndr->depth++;
24305                 ndr_print_ptr(ndr, "handle", r->in.handle);
24306                 ndr->depth++;
24307                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24308                 ndr->depth--;
24309                 ndr_print_string(ndr, "form_name", r->in.form_name);
24310                 ndr_print_uint32(ndr, "level", r->in.level);
24311                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
24312                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
24313                 ndr->depth--;
24314         }
24315         if (flags & NDR_OUT) {
24316                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
24317                 ndr->depth++;
24318                 ndr_print_WERROR(ndr, "result", r->out.result);
24319                 ndr->depth--;
24320         }
24321         ndr->depth--;
24322 }
24323
24324 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
24325 {
24326         if (flags & NDR_IN) {
24327                 if (r->in.handle == NULL) {
24328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24329                 }
24330                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24332                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24333                 if (r->in.buffer) {
24334                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24335                 }
24336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24337         }
24338         if (flags & NDR_OUT) {
24339                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24340                 if (r->out.info) {
24341                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24342                 }
24343                 if (r->out.needed == NULL) {
24344                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24345                 }
24346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24347                 if (r->out.count == NULL) {
24348                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24349                 }
24350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24351                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24352         }
24353         return NDR_ERR_SUCCESS;
24354 }
24355
24356 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
24357 {
24358         uint32_t _ptr_buffer;
24359         uint32_t _ptr_info;
24360         TALLOC_CTX *_mem_save_handle_0;
24361         TALLOC_CTX *_mem_save_buffer_0;
24362         TALLOC_CTX *_mem_save_info_0;
24363         TALLOC_CTX *_mem_save_needed_0;
24364         TALLOC_CTX *_mem_save_count_0;
24365         if (flags & NDR_IN) {
24366                 ZERO_STRUCT(r->out);
24367
24368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24369                         NDR_PULL_ALLOC(ndr, r->in.handle);
24370                 }
24371                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24372                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24373                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24377                 if (_ptr_buffer) {
24378                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24379                 } else {
24380                         r->in.buffer = NULL;
24381                 }
24382                 if (r->in.buffer) {
24383                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24384                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24385                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24387                 }
24388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24389                 NDR_PULL_ALLOC(ndr, r->out.needed);
24390                 ZERO_STRUCTP(r->out.needed);
24391                 NDR_PULL_ALLOC(ndr, r->out.count);
24392                 ZERO_STRUCTP(r->out.count);
24393         }
24394         if (flags & NDR_OUT) {
24395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24396                 if (_ptr_info) {
24397                         NDR_PULL_ALLOC(ndr, r->out.info);
24398                 } else {
24399                         r->out.info = NULL;
24400                 }
24401                 if (r->out.info) {
24402                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24403                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24404                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24406                 }
24407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24408                         NDR_PULL_ALLOC(ndr, r->out.needed);
24409                 }
24410                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24411                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24415                         NDR_PULL_ALLOC(ndr, r->out.count);
24416                 }
24417                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24418                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24421                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24422         }
24423         return NDR_ERR_SUCCESS;
24424 }
24425
24426 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
24427 {
24428         uint32_t cntr_info_0;
24429         if (flags & NDR_IN) {
24430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24432         }
24433         if (flags & NDR_OUT) {
24434                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24435                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24436                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24437                 }
24438                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24439                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24440                 }
24441         }
24442         return NDR_ERR_SUCCESS;
24443 }
24444
24445 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
24446 {
24447         uint32_t cntr_info_0;
24448         TALLOC_CTX *_mem_save_info_0;
24449         if (flags & NDR_IN) {
24450                 ZERO_STRUCT(r->out);
24451
24452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24453                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24454         }
24455         if (flags & NDR_OUT) {
24456                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24457                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24458                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24459                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24460                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24461                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24462                 }
24463                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24464                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24465                 }
24466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24467         }
24468         return NDR_ERR_SUCCESS;
24469 }
24470
24471 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
24472 {
24473         uint32_t cntr_info_2;
24474         ndr_print_struct(ndr, name, "spoolss_EnumForms");
24475         ndr->depth++;
24476         if (flags & NDR_SET_VALUES) {
24477                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24478         }
24479         if (flags & NDR_IN) {
24480                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
24481                 ndr->depth++;
24482                 ndr_print_ptr(ndr, "handle", r->in.handle);
24483                 ndr->depth++;
24484                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24485                 ndr->depth--;
24486                 ndr_print_uint32(ndr, "level", r->in.level);
24487                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24488                 ndr->depth++;
24489                 if (r->in.buffer) {
24490                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24491                 }
24492                 ndr->depth--;
24493                 ndr_print_uint32(ndr, "offered", r->in.offered);
24494                 ndr->depth--;
24495         }
24496         if (flags & NDR_OUT) {
24497                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
24498                 ndr->depth++;
24499                 ndr_print_ptr(ndr, "count", r->out.count);
24500                 ndr->depth++;
24501                 ndr_print_uint32(ndr, "count", *r->out.count);
24502                 ndr->depth--;
24503                 ndr_print_ptr(ndr, "info", r->out.info);
24504                 ndr->depth++;
24505                 ndr_print_ptr(ndr, "info", *r->out.info);
24506                 ndr->depth++;
24507                 if (*r->out.info) {
24508                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24509                         ndr->depth++;
24510                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24511                                 char *idx_2=NULL;
24512                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24513                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24514                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24515                                         free(idx_2);
24516                                 }
24517                         }
24518                         ndr->depth--;
24519                 }
24520                 ndr->depth--;
24521                 ndr->depth--;
24522                 ndr_print_ptr(ndr, "needed", r->out.needed);
24523                 ndr->depth++;
24524                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24525                 ndr->depth--;
24526                 ndr_print_WERROR(ndr, "result", r->out.result);
24527                 ndr->depth--;
24528         }
24529         ndr->depth--;
24530 }
24531
24532 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
24533 {
24534         if (flags & NDR_IN) {
24535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24536                 if (r->in.servername) {
24537                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24538                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24540                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24541                 }
24542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24544                 if (r->in.buffer) {
24545                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24546                 }
24547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24548         }
24549         if (flags & NDR_OUT) {
24550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24551                 if (r->out.info) {
24552                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24553                 }
24554                 if (r->out.needed == NULL) {
24555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24556                 }
24557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24558                 if (r->out.count == NULL) {
24559                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24560                 }
24561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24562                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24563         }
24564         return NDR_ERR_SUCCESS;
24565 }
24566
24567 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
24568 {
24569         uint32_t _ptr_servername;
24570         uint32_t _ptr_buffer;
24571         uint32_t _ptr_info;
24572         TALLOC_CTX *_mem_save_servername_0;
24573         TALLOC_CTX *_mem_save_buffer_0;
24574         TALLOC_CTX *_mem_save_info_0;
24575         TALLOC_CTX *_mem_save_needed_0;
24576         TALLOC_CTX *_mem_save_count_0;
24577         if (flags & NDR_IN) {
24578                 ZERO_STRUCT(r->out);
24579
24580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24581                 if (_ptr_servername) {
24582                         NDR_PULL_ALLOC(ndr, r->in.servername);
24583                 } else {
24584                         r->in.servername = NULL;
24585                 }
24586                 if (r->in.servername) {
24587                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24588                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24589                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24590                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24591                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24592                                 return 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));
24593                         }
24594                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24595                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24597                 }
24598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24600                 if (_ptr_buffer) {
24601                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24602                 } else {
24603                         r->in.buffer = NULL;
24604                 }
24605                 if (r->in.buffer) {
24606                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24607                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24608                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24609                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24610                 }
24611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24612                 NDR_PULL_ALLOC(ndr, r->out.needed);
24613                 ZERO_STRUCTP(r->out.needed);
24614                 NDR_PULL_ALLOC(ndr, r->out.count);
24615                 ZERO_STRUCTP(r->out.count);
24616         }
24617         if (flags & NDR_OUT) {
24618                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24619                 if (_ptr_info) {
24620                         NDR_PULL_ALLOC(ndr, r->out.info);
24621                 } else {
24622                         r->out.info = NULL;
24623                 }
24624                 if (r->out.info) {
24625                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24626                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24627                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24628                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24629                 }
24630                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24631                         NDR_PULL_ALLOC(ndr, r->out.needed);
24632                 }
24633                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24634                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24636                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24637                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24638                         NDR_PULL_ALLOC(ndr, r->out.count);
24639                 }
24640                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24641                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24643                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24645         }
24646         return NDR_ERR_SUCCESS;
24647 }
24648
24649 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
24650 {
24651         uint32_t cntr_info_0;
24652         if (flags & NDR_IN) {
24653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24655         }
24656         if (flags & NDR_OUT) {
24657                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24658                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24659                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24660                 }
24661                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24662                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24663                 }
24664         }
24665         return NDR_ERR_SUCCESS;
24666 }
24667
24668 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
24669 {
24670         uint32_t cntr_info_0;
24671         TALLOC_CTX *_mem_save_info_0;
24672         if (flags & NDR_IN) {
24673                 ZERO_STRUCT(r->out);
24674
24675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24677         }
24678         if (flags & NDR_OUT) {
24679                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24680                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24681                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24682                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24683                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24684                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24685                 }
24686                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24687                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24688                 }
24689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24690         }
24691         return NDR_ERR_SUCCESS;
24692 }
24693
24694 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
24695 {
24696         uint32_t cntr_info_2;
24697         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
24698         ndr->depth++;
24699         if (flags & NDR_SET_VALUES) {
24700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24701         }
24702         if (flags & NDR_IN) {
24703                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
24704                 ndr->depth++;
24705                 ndr_print_ptr(ndr, "servername", r->in.servername);
24706                 ndr->depth++;
24707                 if (r->in.servername) {
24708                         ndr_print_string(ndr, "servername", r->in.servername);
24709                 }
24710                 ndr->depth--;
24711                 ndr_print_uint32(ndr, "level", r->in.level);
24712                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24713                 ndr->depth++;
24714                 if (r->in.buffer) {
24715                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24716                 }
24717                 ndr->depth--;
24718                 ndr_print_uint32(ndr, "offered", r->in.offered);
24719                 ndr->depth--;
24720         }
24721         if (flags & NDR_OUT) {
24722                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
24723                 ndr->depth++;
24724                 ndr_print_ptr(ndr, "count", r->out.count);
24725                 ndr->depth++;
24726                 ndr_print_uint32(ndr, "count", *r->out.count);
24727                 ndr->depth--;
24728                 ndr_print_ptr(ndr, "info", r->out.info);
24729                 ndr->depth++;
24730                 ndr_print_ptr(ndr, "info", *r->out.info);
24731                 ndr->depth++;
24732                 if (*r->out.info) {
24733                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24734                         ndr->depth++;
24735                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24736                                 char *idx_2=NULL;
24737                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24738                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24739                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24740                                         free(idx_2);
24741                                 }
24742                         }
24743                         ndr->depth--;
24744                 }
24745                 ndr->depth--;
24746                 ndr->depth--;
24747                 ndr_print_ptr(ndr, "needed", r->out.needed);
24748                 ndr->depth++;
24749                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24750                 ndr->depth--;
24751                 ndr_print_WERROR(ndr, "result", r->out.result);
24752                 ndr->depth--;
24753         }
24754         ndr->depth--;
24755 }
24756
24757 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
24758 {
24759         if (flags & NDR_IN) {
24760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24761                 if (r->in.servername) {
24762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24766                 }
24767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24769                 if (r->in.buffer) {
24770                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24771                 }
24772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24773         }
24774         if (flags & NDR_OUT) {
24775                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24776                 if (r->out.info) {
24777                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24778                 }
24779                 if (r->out.needed == NULL) {
24780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24781                 }
24782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24783                 if (r->out.count == NULL) {
24784                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24785                 }
24786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24788         }
24789         return NDR_ERR_SUCCESS;
24790 }
24791
24792 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
24793 {
24794         uint32_t _ptr_servername;
24795         uint32_t _ptr_buffer;
24796         uint32_t _ptr_info;
24797         TALLOC_CTX *_mem_save_servername_0;
24798         TALLOC_CTX *_mem_save_buffer_0;
24799         TALLOC_CTX *_mem_save_info_0;
24800         TALLOC_CTX *_mem_save_needed_0;
24801         TALLOC_CTX *_mem_save_count_0;
24802         if (flags & NDR_IN) {
24803                 ZERO_STRUCT(r->out);
24804
24805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24806                 if (_ptr_servername) {
24807                         NDR_PULL_ALLOC(ndr, r->in.servername);
24808                 } else {
24809                         r->in.servername = NULL;
24810                 }
24811                 if (r->in.servername) {
24812                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24813                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24814                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24815                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24816                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24817                                 return 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));
24818                         }
24819                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24820                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24822                 }
24823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24824                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24825                 if (_ptr_buffer) {
24826                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24827                 } else {
24828                         r->in.buffer = NULL;
24829                 }
24830                 if (r->in.buffer) {
24831                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24832                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24833                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24834                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24835                 }
24836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24837                 NDR_PULL_ALLOC(ndr, r->out.needed);
24838                 ZERO_STRUCTP(r->out.needed);
24839                 NDR_PULL_ALLOC(ndr, r->out.count);
24840                 ZERO_STRUCTP(r->out.count);
24841         }
24842         if (flags & NDR_OUT) {
24843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24844                 if (_ptr_info) {
24845                         NDR_PULL_ALLOC(ndr, r->out.info);
24846                 } else {
24847                         r->out.info = NULL;
24848                 }
24849                 if (r->out.info) {
24850                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24851                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24852                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24853                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24854                 }
24855                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24856                         NDR_PULL_ALLOC(ndr, r->out.needed);
24857                 }
24858                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24859                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24861                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24863                         NDR_PULL_ALLOC(ndr, r->out.count);
24864                 }
24865                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24866                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24870         }
24871         return NDR_ERR_SUCCESS;
24872 }
24873
24874 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
24875 {
24876         uint32_t cntr_info_0;
24877         if (flags & NDR_IN) {
24878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24880         }
24881         if (flags & NDR_OUT) {
24882                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24883                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24884                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24885                 }
24886                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24887                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24888                 }
24889         }
24890         return NDR_ERR_SUCCESS;
24891 }
24892
24893 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
24894 {
24895         uint32_t cntr_info_0;
24896         TALLOC_CTX *_mem_save_info_0;
24897         if (flags & NDR_IN) {
24898                 ZERO_STRUCT(r->out);
24899
24900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24902         }
24903         if (flags & NDR_OUT) {
24904                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24905                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24906                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24907                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24908                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24909                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24910                 }
24911                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24912                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24913                 }
24914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24915         }
24916         return NDR_ERR_SUCCESS;
24917 }
24918
24919 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
24920 {
24921         uint32_t cntr_info_2;
24922         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
24923         ndr->depth++;
24924         if (flags & NDR_SET_VALUES) {
24925                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24926         }
24927         if (flags & NDR_IN) {
24928                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
24929                 ndr->depth++;
24930                 ndr_print_ptr(ndr, "servername", r->in.servername);
24931                 ndr->depth++;
24932                 if (r->in.servername) {
24933                         ndr_print_string(ndr, "servername", r->in.servername);
24934                 }
24935                 ndr->depth--;
24936                 ndr_print_uint32(ndr, "level", r->in.level);
24937                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24938                 ndr->depth++;
24939                 if (r->in.buffer) {
24940                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24941                 }
24942                 ndr->depth--;
24943                 ndr_print_uint32(ndr, "offered", r->in.offered);
24944                 ndr->depth--;
24945         }
24946         if (flags & NDR_OUT) {
24947                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
24948                 ndr->depth++;
24949                 ndr_print_ptr(ndr, "count", r->out.count);
24950                 ndr->depth++;
24951                 ndr_print_uint32(ndr, "count", *r->out.count);
24952                 ndr->depth--;
24953                 ndr_print_ptr(ndr, "info", r->out.info);
24954                 ndr->depth++;
24955                 ndr_print_ptr(ndr, "info", *r->out.info);
24956                 ndr->depth++;
24957                 if (*r->out.info) {
24958                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24959                         ndr->depth++;
24960                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24961                                 char *idx_2=NULL;
24962                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24963                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24964                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24965                                         free(idx_2);
24966                                 }
24967                         }
24968                         ndr->depth--;
24969                 }
24970                 ndr->depth--;
24971                 ndr->depth--;
24972                 ndr_print_ptr(ndr, "needed", r->out.needed);
24973                 ndr->depth++;
24974                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24975                 ndr->depth--;
24976                 ndr_print_WERROR(ndr, "result", r->out.result);
24977                 ndr->depth--;
24978         }
24979         ndr->depth--;
24980 }
24981
24982 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
24983 {
24984         if (flags & NDR_IN) {
24985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
24986                 if (r->in.server_name) {
24987                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24990                         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));
24991                 }
24992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
24993                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24994                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
24995                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
24996                 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));
24997         }
24998         if (flags & NDR_OUT) {
24999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25000         }
25001         return NDR_ERR_SUCCESS;
25002 }
25003
25004 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
25005 {
25006         uint32_t _ptr_server_name;
25007         TALLOC_CTX *_mem_save_server_name_0;
25008         if (flags & NDR_IN) {
25009                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
25010                 if (_ptr_server_name) {
25011                         NDR_PULL_ALLOC(ndr, r->in.server_name);
25012                 } else {
25013                         r->in.server_name = NULL;
25014                 }
25015                 if (r->in.server_name) {
25016                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25017                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
25018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
25019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
25020                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
25021                                 return 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));
25022                         }
25023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
25024                         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));
25025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
25026                 }
25027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
25028                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
25029                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
25030                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
25031                         return 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));
25032                 }
25033                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
25034                 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));
25035         }
25036         if (flags & NDR_OUT) {
25037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25038         }
25039         return NDR_ERR_SUCCESS;
25040 }
25041
25042 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
25043 {
25044         ndr_print_struct(ndr, name, "spoolss_AddPort");
25045         ndr->depth++;
25046         if (flags & NDR_SET_VALUES) {
25047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25048         }
25049         if (flags & NDR_IN) {
25050                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
25051                 ndr->depth++;
25052                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
25053                 ndr->depth++;
25054                 if (r->in.server_name) {
25055                         ndr_print_string(ndr, "server_name", r->in.server_name);
25056                 }
25057                 ndr->depth--;
25058                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
25059                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
25060                 ndr->depth--;
25061         }
25062         if (flags & NDR_OUT) {
25063                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
25064                 ndr->depth++;
25065                 ndr_print_WERROR(ndr, "result", r->out.result);
25066                 ndr->depth--;
25067         }
25068         ndr->depth--;
25069 }
25070
25071 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
25072 {
25073         if (flags & NDR_IN) {
25074         }
25075         if (flags & NDR_OUT) {
25076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25077         }
25078         return NDR_ERR_SUCCESS;
25079 }
25080
25081 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
25082 {
25083         if (flags & NDR_IN) {
25084         }
25085         if (flags & NDR_OUT) {
25086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25087         }
25088         return NDR_ERR_SUCCESS;
25089 }
25090
25091 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
25092 {
25093         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
25094         ndr->depth++;
25095         if (flags & NDR_SET_VALUES) {
25096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25097         }
25098         if (flags & NDR_IN) {
25099                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
25100                 ndr->depth++;
25101                 ndr->depth--;
25102         }
25103         if (flags & NDR_OUT) {
25104                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
25105                 ndr->depth++;
25106                 ndr_print_WERROR(ndr, "result", r->out.result);
25107                 ndr->depth--;
25108         }
25109         ndr->depth--;
25110 }
25111
25112 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
25113 {
25114         if (flags & NDR_IN) {
25115         }
25116         if (flags & NDR_OUT) {
25117                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25118         }
25119         return NDR_ERR_SUCCESS;
25120 }
25121
25122 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
25123 {
25124         if (flags & NDR_IN) {
25125         }
25126         if (flags & NDR_OUT) {
25127                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25128         }
25129         return NDR_ERR_SUCCESS;
25130 }
25131
25132 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
25133 {
25134         ndr_print_struct(ndr, name, "spoolss_DeletePort");
25135         ndr->depth++;
25136         if (flags & NDR_SET_VALUES) {
25137                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25138         }
25139         if (flags & NDR_IN) {
25140                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
25141                 ndr->depth++;
25142                 ndr->depth--;
25143         }
25144         if (flags & NDR_OUT) {
25145                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
25146                 ndr->depth++;
25147                 ndr_print_WERROR(ndr, "result", r->out.result);
25148                 ndr->depth--;
25149         }
25150         ndr->depth--;
25151 }
25152
25153 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
25154 {
25155         if (flags & NDR_IN) {
25156                 if (r->in.handle == NULL) {
25157                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25158                 }
25159                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25160                 if (r->in.devmode_ctr == NULL) {
25161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25162                 }
25163                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25164         }
25165         if (flags & NDR_OUT) {
25166                 if (r->out.gdi_handle == NULL) {
25167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25168                 }
25169                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25170                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25171         }
25172         return NDR_ERR_SUCCESS;
25173 }
25174
25175 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
25176 {
25177         TALLOC_CTX *_mem_save_handle_0;
25178         TALLOC_CTX *_mem_save_gdi_handle_0;
25179         TALLOC_CTX *_mem_save_devmode_ctr_0;
25180         if (flags & NDR_IN) {
25181                 ZERO_STRUCT(r->out);
25182
25183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25184                         NDR_PULL_ALLOC(ndr, r->in.handle);
25185                 }
25186                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25187                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25188                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25191                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25192                 }
25193                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25195                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25197                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25198                 ZERO_STRUCTP(r->out.gdi_handle);
25199         }
25200         if (flags & NDR_OUT) {
25201                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25202                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25203                 }
25204                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25205                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25206                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25209         }
25210         return NDR_ERR_SUCCESS;
25211 }
25212
25213 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
25214 {
25215         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
25216         ndr->depth++;
25217         if (flags & NDR_SET_VALUES) {
25218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25219         }
25220         if (flags & NDR_IN) {
25221                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
25222                 ndr->depth++;
25223                 ndr_print_ptr(ndr, "handle", r->in.handle);
25224                 ndr->depth++;
25225                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25226                 ndr->depth--;
25227                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25228                 ndr->depth++;
25229                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25230                 ndr->depth--;
25231                 ndr->depth--;
25232         }
25233         if (flags & NDR_OUT) {
25234                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
25235                 ndr->depth++;
25236                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25237                 ndr->depth++;
25238                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25239                 ndr->depth--;
25240                 ndr_print_WERROR(ndr, "result", r->out.result);
25241                 ndr->depth--;
25242         }
25243         ndr->depth--;
25244 }
25245
25246 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25247 {
25248         if (flags & NDR_IN) {
25249         }
25250         if (flags & NDR_OUT) {
25251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25252         }
25253         return NDR_ERR_SUCCESS;
25254 }
25255
25256 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
25257 {
25258         if (flags & NDR_IN) {
25259         }
25260         if (flags & NDR_OUT) {
25261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25262         }
25263         return NDR_ERR_SUCCESS;
25264 }
25265
25266 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
25267 {
25268         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
25269         ndr->depth++;
25270         if (flags & NDR_SET_VALUES) {
25271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25272         }
25273         if (flags & NDR_IN) {
25274                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
25275                 ndr->depth++;
25276                 ndr->depth--;
25277         }
25278         if (flags & NDR_OUT) {
25279                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
25280                 ndr->depth++;
25281                 ndr_print_WERROR(ndr, "result", r->out.result);
25282                 ndr->depth--;
25283         }
25284         ndr->depth--;
25285 }
25286
25287 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
25288 {
25289         if (flags & NDR_IN) {
25290                 if (r->in.gdi_handle == NULL) {
25291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25292                 }
25293                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25294         }
25295         if (flags & NDR_OUT) {
25296                 if (r->out.gdi_handle == NULL) {
25297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25298                 }
25299                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25301         }
25302         return NDR_ERR_SUCCESS;
25303 }
25304
25305 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
25306 {
25307         TALLOC_CTX *_mem_save_gdi_handle_0;
25308         if (flags & NDR_IN) {
25309                 ZERO_STRUCT(r->out);
25310
25311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25312                         NDR_PULL_ALLOC(ndr, r->in.gdi_handle);
25313                 }
25314                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25316                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.gdi_handle));
25317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25318                 NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25319                 *r->out.gdi_handle = *r->in.gdi_handle;
25320         }
25321         if (flags & NDR_OUT) {
25322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25323                         NDR_PULL_ALLOC(ndr, r->out.gdi_handle);
25324                 }
25325                 _mem_save_gdi_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25326                 NDR_PULL_SET_MEM_CTX(ndr, r->out.gdi_handle, LIBNDR_FLAG_REF_ALLOC);
25327                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.gdi_handle));
25328                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_gdi_handle_0, LIBNDR_FLAG_REF_ALLOC);
25329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25330         }
25331         return NDR_ERR_SUCCESS;
25332 }
25333
25334 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
25335 {
25336         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
25337         ndr->depth++;
25338         if (flags & NDR_SET_VALUES) {
25339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25340         }
25341         if (flags & NDR_IN) {
25342                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
25343                 ndr->depth++;
25344                 ndr_print_ptr(ndr, "gdi_handle", r->in.gdi_handle);
25345                 ndr->depth++;
25346                 ndr_print_policy_handle(ndr, "gdi_handle", r->in.gdi_handle);
25347                 ndr->depth--;
25348                 ndr->depth--;
25349         }
25350         if (flags & NDR_OUT) {
25351                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
25352                 ndr->depth++;
25353                 ndr_print_ptr(ndr, "gdi_handle", r->out.gdi_handle);
25354                 ndr->depth++;
25355                 ndr_print_policy_handle(ndr, "gdi_handle", r->out.gdi_handle);
25356                 ndr->depth--;
25357                 ndr_print_WERROR(ndr, "result", r->out.result);
25358                 ndr->depth--;
25359         }
25360         ndr->depth--;
25361 }
25362
25363 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
25364 {
25365         if (flags & NDR_IN) {
25366         }
25367         if (flags & NDR_OUT) {
25368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25369         }
25370         return NDR_ERR_SUCCESS;
25371 }
25372
25373 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
25374 {
25375         if (flags & NDR_IN) {
25376         }
25377         if (flags & NDR_OUT) {
25378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25379         }
25380         return NDR_ERR_SUCCESS;
25381 }
25382
25383 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
25384 {
25385         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
25386         ndr->depth++;
25387         if (flags & NDR_SET_VALUES) {
25388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25389         }
25390         if (flags & NDR_IN) {
25391                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
25392                 ndr->depth++;
25393                 ndr->depth--;
25394         }
25395         if (flags & NDR_OUT) {
25396                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
25397                 ndr->depth++;
25398                 ndr_print_WERROR(ndr, "result", r->out.result);
25399                 ndr->depth--;
25400         }
25401         ndr->depth--;
25402 }
25403
25404 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
25405 {
25406         if (flags & NDR_IN) {
25407         }
25408         if (flags & NDR_OUT) {
25409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25410         }
25411         return NDR_ERR_SUCCESS;
25412 }
25413
25414 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
25415 {
25416         if (flags & NDR_IN) {
25417         }
25418         if (flags & NDR_OUT) {
25419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25420         }
25421         return NDR_ERR_SUCCESS;
25422 }
25423
25424 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
25425 {
25426         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
25427         ndr->depth++;
25428         if (flags & NDR_SET_VALUES) {
25429                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25430         }
25431         if (flags & NDR_IN) {
25432                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
25433                 ndr->depth++;
25434                 ndr->depth--;
25435         }
25436         if (flags & NDR_OUT) {
25437                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
25438                 ndr->depth++;
25439                 ndr_print_WERROR(ndr, "result", r->out.result);
25440                 ndr->depth--;
25441         }
25442         ndr->depth--;
25443 }
25444
25445 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
25446 {
25447         if (flags & NDR_IN) {
25448         }
25449         if (flags & NDR_OUT) {
25450                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25451         }
25452         return NDR_ERR_SUCCESS;
25453 }
25454
25455 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
25456 {
25457         if (flags & NDR_IN) {
25458         }
25459         if (flags & NDR_OUT) {
25460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25461         }
25462         return NDR_ERR_SUCCESS;
25463 }
25464
25465 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
25466 {
25467         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
25468         ndr->depth++;
25469         if (flags & NDR_SET_VALUES) {
25470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25471         }
25472         if (flags & NDR_IN) {
25473                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
25474                 ndr->depth++;
25475                 ndr->depth--;
25476         }
25477         if (flags & NDR_OUT) {
25478                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
25479                 ndr->depth++;
25480                 ndr_print_WERROR(ndr, "result", r->out.result);
25481                 ndr->depth--;
25482         }
25483         ndr->depth--;
25484 }
25485
25486 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
25487 {
25488         if (flags & NDR_IN) {
25489         }
25490         if (flags & NDR_OUT) {
25491                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25492         }
25493         return NDR_ERR_SUCCESS;
25494 }
25495
25496 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
25497 {
25498         if (flags & NDR_IN) {
25499         }
25500         if (flags & NDR_OUT) {
25501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25502         }
25503         return NDR_ERR_SUCCESS;
25504 }
25505
25506 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
25507 {
25508         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
25509         ndr->depth++;
25510         if (flags & NDR_SET_VALUES) {
25511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25512         }
25513         if (flags & NDR_IN) {
25514                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
25515                 ndr->depth++;
25516                 ndr->depth--;
25517         }
25518         if (flags & NDR_OUT) {
25519                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
25520                 ndr->depth++;
25521                 ndr_print_WERROR(ndr, "result", r->out.result);
25522                 ndr->depth--;
25523         }
25524         ndr->depth--;
25525 }
25526
25527 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
25528 {
25529         if (flags & NDR_IN) {
25530         }
25531         if (flags & NDR_OUT) {
25532                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25533         }
25534         return NDR_ERR_SUCCESS;
25535 }
25536
25537 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
25538 {
25539         if (flags & NDR_IN) {
25540         }
25541         if (flags & NDR_OUT) {
25542                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25543         }
25544         return NDR_ERR_SUCCESS;
25545 }
25546
25547 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
25548 {
25549         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
25550         ndr->depth++;
25551         if (flags & NDR_SET_VALUES) {
25552                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25553         }
25554         if (flags & NDR_IN) {
25555                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
25556                 ndr->depth++;
25557                 ndr->depth--;
25558         }
25559         if (flags & NDR_OUT) {
25560                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
25561                 ndr->depth++;
25562                 ndr_print_WERROR(ndr, "result", r->out.result);
25563                 ndr->depth--;
25564         }
25565         ndr->depth--;
25566 }
25567
25568 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
25569 {
25570         if (flags & NDR_IN) {
25571         }
25572         if (flags & NDR_OUT) {
25573                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25574         }
25575         return NDR_ERR_SUCCESS;
25576 }
25577
25578 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
25579 {
25580         if (flags & NDR_IN) {
25581         }
25582         if (flags & NDR_OUT) {
25583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25584         }
25585         return NDR_ERR_SUCCESS;
25586 }
25587
25588 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
25589 {
25590         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
25591         ndr->depth++;
25592         if (flags & NDR_SET_VALUES) {
25593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25594         }
25595         if (flags & NDR_IN) {
25596                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
25597                 ndr->depth++;
25598                 ndr->depth--;
25599         }
25600         if (flags & NDR_OUT) {
25601                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
25602                 ndr->depth++;
25603                 ndr_print_WERROR(ndr, "result", r->out.result);
25604                 ndr->depth--;
25605         }
25606         ndr->depth--;
25607 }
25608
25609 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
25610 {
25611         if (flags & NDR_IN) {
25612         }
25613         if (flags & NDR_OUT) {
25614                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25615         }
25616         return NDR_ERR_SUCCESS;
25617 }
25618
25619 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
25620 {
25621         if (flags & NDR_IN) {
25622         }
25623         if (flags & NDR_OUT) {
25624                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25625         }
25626         return NDR_ERR_SUCCESS;
25627 }
25628
25629 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
25630 {
25631         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
25632         ndr->depth++;
25633         if (flags & NDR_SET_VALUES) {
25634                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25635         }
25636         if (flags & NDR_IN) {
25637                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
25638                 ndr->depth++;
25639                 ndr->depth--;
25640         }
25641         if (flags & NDR_OUT) {
25642                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
25643                 ndr->depth++;
25644                 ndr_print_WERROR(ndr, "result", r->out.result);
25645                 ndr->depth--;
25646         }
25647         ndr->depth--;
25648 }
25649
25650 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
25651 {
25652         if (flags & NDR_IN) {
25653         }
25654         if (flags & NDR_OUT) {
25655                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25656         }
25657         return NDR_ERR_SUCCESS;
25658 }
25659
25660 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
25661 {
25662         if (flags & NDR_IN) {
25663         }
25664         if (flags & NDR_OUT) {
25665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25666         }
25667         return NDR_ERR_SUCCESS;
25668 }
25669
25670 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
25671 {
25672         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
25673         ndr->depth++;
25674         if (flags & NDR_SET_VALUES) {
25675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25676         }
25677         if (flags & NDR_IN) {
25678                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
25679                 ndr->depth++;
25680                 ndr->depth--;
25681         }
25682         if (flags & NDR_OUT) {
25683                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
25684                 ndr->depth++;
25685                 ndr_print_WERROR(ndr, "result", r->out.result);
25686                 ndr->depth--;
25687         }
25688         ndr->depth--;
25689 }
25690
25691 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
25692 {
25693         if (flags & NDR_IN) {
25694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
25695                 if (r->in.servername) {
25696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
25699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25700                 }
25701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
25702                 if (r->in.print_processor_name) {
25703                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25705                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
25706                         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));
25707                 }
25708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25709                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
25710                 if (r->in.buffer) {
25711                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
25712                 }
25713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25714         }
25715         if (flags & NDR_OUT) {
25716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
25717                 if (r->out.info) {
25718                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
25719                 }
25720                 if (r->out.needed == NULL) {
25721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25722                 }
25723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25724                 if (r->out.count == NULL) {
25725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25726                 }
25727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
25728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25729         }
25730         return NDR_ERR_SUCCESS;
25731 }
25732
25733 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
25734 {
25735         uint32_t _ptr_servername;
25736         uint32_t _ptr_print_processor_name;
25737         uint32_t _ptr_buffer;
25738         uint32_t _ptr_info;
25739         TALLOC_CTX *_mem_save_servername_0;
25740         TALLOC_CTX *_mem_save_print_processor_name_0;
25741         TALLOC_CTX *_mem_save_buffer_0;
25742         TALLOC_CTX *_mem_save_info_0;
25743         TALLOC_CTX *_mem_save_needed_0;
25744         TALLOC_CTX *_mem_save_count_0;
25745         if (flags & NDR_IN) {
25746                 ZERO_STRUCT(r->out);
25747
25748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
25749                 if (_ptr_servername) {
25750                         NDR_PULL_ALLOC(ndr, r->in.servername);
25751                 } else {
25752                         r->in.servername = NULL;
25753                 }
25754                 if (r->in.servername) {
25755                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25756                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
25757                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
25758                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
25759                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
25760                                 return 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));
25761                         }
25762                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
25763                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
25764                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
25765                 }
25766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
25767                 if (_ptr_print_processor_name) {
25768                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
25769                 } else {
25770                         r->in.print_processor_name = NULL;
25771                 }
25772                 if (r->in.print_processor_name) {
25773                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
25774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
25775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
25776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
25777                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
25778                                 return 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));
25779                         }
25780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
25781                         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));
25782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
25783                 }
25784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
25786                 if (_ptr_buffer) {
25787                         NDR_PULL_ALLOC(ndr, r->in.buffer);
25788                 } else {
25789                         r->in.buffer = NULL;
25790                 }
25791                 if (r->in.buffer) {
25792                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25793                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
25794                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
25795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
25796                 }
25797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25798                 NDR_PULL_ALLOC(ndr, r->out.needed);
25799                 ZERO_STRUCTP(r->out.needed);
25800                 NDR_PULL_ALLOC(ndr, r->out.count);
25801                 ZERO_STRUCTP(r->out.count);
25802         }
25803         if (flags & NDR_OUT) {
25804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25805                 if (_ptr_info) {
25806                         NDR_PULL_ALLOC(ndr, r->out.info);
25807                 } else {
25808                         r->out.info = NULL;
25809                 }
25810                 if (r->out.info) {
25811                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25812                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25813                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
25814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25815                 }
25816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25817                         NDR_PULL_ALLOC(ndr, r->out.needed);
25818                 }
25819                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
25821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
25822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
25823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25824                         NDR_PULL_ALLOC(ndr, r->out.count);
25825                 }
25826                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
25827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
25828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
25829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
25830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25831         }
25832         return NDR_ERR_SUCCESS;
25833 }
25834
25835 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
25836 {
25837         uint32_t cntr_info_0;
25838         if (flags & NDR_IN) {
25839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
25841         }
25842         if (flags & NDR_OUT) {
25843                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25844                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25845                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25846                 }
25847                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25848                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25849                 }
25850         }
25851         return NDR_ERR_SUCCESS;
25852 }
25853
25854 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
25855 {
25856         uint32_t cntr_info_0;
25857         TALLOC_CTX *_mem_save_info_0;
25858         if (flags & NDR_IN) {
25859                 ZERO_STRUCT(r->out);
25860
25861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
25863         }
25864         if (flags & NDR_OUT) {
25865                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
25866                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25867                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
25868                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25869                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
25870                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
25871                 }
25872                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
25873                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
25874                 }
25875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
25876         }
25877         return NDR_ERR_SUCCESS;
25878 }
25879
25880 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
25881 {
25882         uint32_t cntr_info_2;
25883         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
25884         ndr->depth++;
25885         if (flags & NDR_SET_VALUES) {
25886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25887         }
25888         if (flags & NDR_IN) {
25889                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
25890                 ndr->depth++;
25891                 ndr_print_ptr(ndr, "servername", r->in.servername);
25892                 ndr->depth++;
25893                 if (r->in.servername) {
25894                         ndr_print_string(ndr, "servername", r->in.servername);
25895                 }
25896                 ndr->depth--;
25897                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
25898                 ndr->depth++;
25899                 if (r->in.print_processor_name) {
25900                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
25901                 }
25902                 ndr->depth--;
25903                 ndr_print_uint32(ndr, "level", r->in.level);
25904                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25905                 ndr->depth++;
25906                 if (r->in.buffer) {
25907                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
25908                 }
25909                 ndr->depth--;
25910                 ndr_print_uint32(ndr, "offered", r->in.offered);
25911                 ndr->depth--;
25912         }
25913         if (flags & NDR_OUT) {
25914                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
25915                 ndr->depth++;
25916                 ndr_print_ptr(ndr, "count", r->out.count);
25917                 ndr->depth++;
25918                 ndr_print_uint32(ndr, "count", *r->out.count);
25919                 ndr->depth--;
25920                 ndr_print_ptr(ndr, "info", r->out.info);
25921                 ndr->depth++;
25922                 ndr_print_ptr(ndr, "info", *r->out.info);
25923                 ndr->depth++;
25924                 if (*r->out.info) {
25925                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
25926                         ndr->depth++;
25927                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
25928                                 char *idx_2=NULL;
25929                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
25930                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
25931                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
25932                                         free(idx_2);
25933                                 }
25934                         }
25935                         ndr->depth--;
25936                 }
25937                 ndr->depth--;
25938                 ndr->depth--;
25939                 ndr_print_ptr(ndr, "needed", r->out.needed);
25940                 ndr->depth++;
25941                 ndr_print_uint32(ndr, "needed", *r->out.needed);
25942                 ndr->depth--;
25943                 ndr_print_WERROR(ndr, "result", r->out.result);
25944                 ndr->depth--;
25945         }
25946         ndr->depth--;
25947 }
25948
25949 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
25950 {
25951         if (flags & NDR_IN) {
25952                 if (r->in.handle == NULL) {
25953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25954                 }
25955                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25956                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
25957                 if (r->in.data_type) {
25958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
25960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
25961                         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));
25962                 }
25963                 if (r->in.devmode_ctr == NULL) {
25964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25965                 }
25966                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25967         }
25968         if (flags & NDR_OUT) {
25969                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25970         }
25971         return NDR_ERR_SUCCESS;
25972 }
25973
25974 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
25975 {
25976         uint32_t _ptr_data_type;
25977         TALLOC_CTX *_mem_save_handle_0;
25978         TALLOC_CTX *_mem_save_data_type_0;
25979         TALLOC_CTX *_mem_save_devmode_ctr_0;
25980         if (flags & NDR_IN) {
25981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25982                         NDR_PULL_ALLOC(ndr, r->in.handle);
25983                 }
25984                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25985                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25986                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
25989                 if (_ptr_data_type) {
25990                         NDR_PULL_ALLOC(ndr, r->in.data_type);
25991                 } else {
25992                         r->in.data_type = NULL;
25993                 }
25994                 if (r->in.data_type) {
25995                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25996                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
25997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
25998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
25999                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
26000                                 return 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));
26001                         }
26002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
26003                         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));
26004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
26005                 }
26006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26007                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
26008                 }
26009                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26010                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
26011                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
26012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26013         }
26014         if (flags & NDR_OUT) {
26015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26016         }
26017         return NDR_ERR_SUCCESS;
26018 }
26019
26020 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
26021 {
26022         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
26023         ndr->depth++;
26024         if (flags & NDR_SET_VALUES) {
26025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26026         }
26027         if (flags & NDR_IN) {
26028                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
26029                 ndr->depth++;
26030                 ndr_print_ptr(ndr, "handle", r->in.handle);
26031                 ndr->depth++;
26032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26033                 ndr->depth--;
26034                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
26035                 ndr->depth++;
26036                 if (r->in.data_type) {
26037                         ndr_print_string(ndr, "data_type", r->in.data_type);
26038                 }
26039                 ndr->depth--;
26040                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
26041                 ndr->depth++;
26042                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
26043                 ndr->depth--;
26044                 ndr->depth--;
26045         }
26046         if (flags & NDR_OUT) {
26047                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
26048                 ndr->depth++;
26049                 ndr_print_WERROR(ndr, "result", r->out.result);
26050                 ndr->depth--;
26051         }
26052         ndr->depth--;
26053 }
26054
26055 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
26056 {
26057         if (flags & NDR_IN) {
26058                 if (r->in.handle == NULL) {
26059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26060                 }
26061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
26063                 if (r->in.architecture) {
26064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26067                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26068                 }
26069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
26070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26071                 if (r->in.buffer) {
26072                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
26073                 }
26074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
26076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
26077         }
26078         if (flags & NDR_OUT) {
26079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
26080                 if (r->out.info) {
26081                         {
26082                                 struct ndr_push *_ndr_info;
26083                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26084                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
26085                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26086                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26087                         }
26088                 }
26089                 if (r->out.needed == NULL) {
26090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26091                 }
26092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26093                 if (r->out.server_major_version == NULL) {
26094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26095                 }
26096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
26097                 if (r->out.server_minor_version == NULL) {
26098                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26099                 }
26100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
26101                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26102         }
26103         return NDR_ERR_SUCCESS;
26104 }
26105
26106 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
26107 {
26108         uint32_t _ptr_architecture;
26109         uint32_t _ptr_buffer;
26110         uint32_t _ptr_info;
26111         TALLOC_CTX *_mem_save_handle_0;
26112         TALLOC_CTX *_mem_save_architecture_0;
26113         TALLOC_CTX *_mem_save_buffer_0;
26114         TALLOC_CTX *_mem_save_info_0;
26115         TALLOC_CTX *_mem_save_needed_0;
26116         TALLOC_CTX *_mem_save_server_major_version_0;
26117         TALLOC_CTX *_mem_save_server_minor_version_0;
26118         if (flags & NDR_IN) {
26119                 ZERO_STRUCT(r->out);
26120
26121                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26122                         NDR_PULL_ALLOC(ndr, r->in.handle);
26123                 }
26124                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26125                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26126                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
26129                 if (_ptr_architecture) {
26130                         NDR_PULL_ALLOC(ndr, r->in.architecture);
26131                 } else {
26132                         r->in.architecture = NULL;
26133                 }
26134                 if (r->in.architecture) {
26135                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
26136                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
26137                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26138                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26139                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26140                                 return 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));
26141                         }
26142                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26143                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26144                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
26145                 }
26146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
26147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26148                 if (_ptr_buffer) {
26149                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26150                 } else {
26151                         r->in.buffer = NULL;
26152                 }
26153                 if (r->in.buffer) {
26154                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26155                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26156                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
26157                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26158                 }
26159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
26161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
26162                 NDR_PULL_ALLOC(ndr, r->out.needed);
26163                 ZERO_STRUCTP(r->out.needed);
26164                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26165                 ZERO_STRUCTP(r->out.server_major_version);
26166                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26167                 ZERO_STRUCTP(r->out.server_minor_version);
26168         }
26169         if (flags & NDR_OUT) {
26170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
26171                 if (_ptr_info) {
26172                         NDR_PULL_ALLOC(ndr, r->out.info);
26173                 } else {
26174                         r->out.info = NULL;
26175                 }
26176                 if (r->out.info) {
26177                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26178                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26179                         {
26180                                 struct ndr_pull *_ndr_info;
26181                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
26182                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
26183                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
26184                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
26185                         }
26186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26187                 }
26188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26189                         NDR_PULL_ALLOC(ndr, r->out.needed);
26190                 }
26191                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26192                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26196                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
26197                 }
26198                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26199                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
26200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
26201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
26202                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26203                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
26204                 }
26205                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
26206                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
26207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
26208                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
26209                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26210         }
26211         return NDR_ERR_SUCCESS;
26212 }
26213
26214 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
26215 {
26216         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
26217         ndr->depth++;
26218         if (flags & NDR_SET_VALUES) {
26219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26220         }
26221         if (flags & NDR_IN) {
26222                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
26223                 ndr->depth++;
26224                 ndr_print_ptr(ndr, "handle", r->in.handle);
26225                 ndr->depth++;
26226                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26227                 ndr->depth--;
26228                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
26229                 ndr->depth++;
26230                 if (r->in.architecture) {
26231                         ndr_print_string(ndr, "architecture", r->in.architecture);
26232                 }
26233                 ndr->depth--;
26234                 ndr_print_uint32(ndr, "level", r->in.level);
26235                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26236                 ndr->depth++;
26237                 if (r->in.buffer) {
26238                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
26239                 }
26240                 ndr->depth--;
26241                 ndr_print_uint32(ndr, "offered", r->in.offered);
26242                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
26243                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
26244                 ndr->depth--;
26245         }
26246         if (flags & NDR_OUT) {
26247                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
26248                 ndr->depth++;
26249                 ndr_print_ptr(ndr, "info", r->out.info);
26250                 ndr->depth++;
26251                 if (r->out.info) {
26252                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
26253                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
26254                 }
26255                 ndr->depth--;
26256                 ndr_print_ptr(ndr, "needed", r->out.needed);
26257                 ndr->depth++;
26258                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26259                 ndr->depth--;
26260                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
26261                 ndr->depth++;
26262                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
26263                 ndr->depth--;
26264                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
26265                 ndr->depth++;
26266                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
26267                 ndr->depth--;
26268                 ndr_print_WERROR(ndr, "result", r->out.result);
26269                 ndr->depth--;
26270         }
26271         ndr->depth--;
26272 }
26273
26274 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26275 {
26276         if (flags & NDR_IN) {
26277         }
26278         if (flags & NDR_OUT) {
26279                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26280         }
26281         return NDR_ERR_SUCCESS;
26282 }
26283
26284 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
26285 {
26286         if (flags & NDR_IN) {
26287         }
26288         if (flags & NDR_OUT) {
26289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26290         }
26291         return NDR_ERR_SUCCESS;
26292 }
26293
26294 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
26295 {
26296         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
26297         ndr->depth++;
26298         if (flags & NDR_SET_VALUES) {
26299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26300         }
26301         if (flags & NDR_IN) {
26302                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
26303                 ndr->depth++;
26304                 ndr->depth--;
26305         }
26306         if (flags & NDR_OUT) {
26307                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
26308                 ndr->depth++;
26309                 ndr_print_WERROR(ndr, "result", r->out.result);
26310                 ndr->depth--;
26311         }
26312         ndr->depth--;
26313 }
26314
26315 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26316 {
26317         if (flags & NDR_IN) {
26318         }
26319         if (flags & NDR_OUT) {
26320                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26321         }
26322         return NDR_ERR_SUCCESS;
26323 }
26324
26325 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
26326 {
26327         if (flags & NDR_IN) {
26328         }
26329         if (flags & NDR_OUT) {
26330                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26331         }
26332         return NDR_ERR_SUCCESS;
26333 }
26334
26335 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
26336 {
26337         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
26338         ndr->depth++;
26339         if (flags & NDR_SET_VALUES) {
26340                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26341         }
26342         if (flags & NDR_IN) {
26343                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
26344                 ndr->depth++;
26345                 ndr->depth--;
26346         }
26347         if (flags & NDR_OUT) {
26348                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
26349                 ndr->depth++;
26350                 ndr_print_WERROR(ndr, "result", r->out.result);
26351                 ndr->depth--;
26352         }
26353         ndr->depth--;
26354 }
26355
26356 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
26357 {
26358         if (flags & NDR_IN) {
26359                 if (r->in.handle == NULL) {
26360                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26361                 }
26362                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26363         }
26364         if (flags & NDR_OUT) {
26365                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26366         }
26367         return NDR_ERR_SUCCESS;
26368 }
26369
26370 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
26371 {
26372         TALLOC_CTX *_mem_save_handle_0;
26373         if (flags & NDR_IN) {
26374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26375                         NDR_PULL_ALLOC(ndr, r->in.handle);
26376                 }
26377                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26378                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26379                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26381         }
26382         if (flags & NDR_OUT) {
26383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26384         }
26385         return NDR_ERR_SUCCESS;
26386 }
26387
26388 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
26389 {
26390         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
26391         ndr->depth++;
26392         if (flags & NDR_SET_VALUES) {
26393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26394         }
26395         if (flags & NDR_IN) {
26396                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
26397                 ndr->depth++;
26398                 ndr_print_ptr(ndr, "handle", r->in.handle);
26399                 ndr->depth++;
26400                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26401                 ndr->depth--;
26402                 ndr->depth--;
26403         }
26404         if (flags & NDR_OUT) {
26405                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
26406                 ndr->depth++;
26407                 ndr_print_WERROR(ndr, "result", r->out.result);
26408                 ndr->depth--;
26409         }
26410         ndr->depth--;
26411 }
26412
26413 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26414 {
26415         if (flags & NDR_IN) {
26416         }
26417         if (flags & NDR_OUT) {
26418                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26419         }
26420         return NDR_ERR_SUCCESS;
26421 }
26422
26423 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26424 {
26425         if (flags & NDR_IN) {
26426         }
26427         if (flags & NDR_OUT) {
26428                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26429         }
26430         return NDR_ERR_SUCCESS;
26431 }
26432
26433 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
26434 {
26435         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26436         ndr->depth++;
26437         if (flags & NDR_SET_VALUES) {
26438                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26439         }
26440         if (flags & NDR_IN) {
26441                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26442                 ndr->depth++;
26443                 ndr->depth--;
26444         }
26445         if (flags & NDR_OUT) {
26446                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
26447                 ndr->depth++;
26448                 ndr_print_WERROR(ndr, "result", r->out.result);
26449                 ndr->depth--;
26450         }
26451         ndr->depth--;
26452 }
26453
26454 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
26455 {
26456         if (flags & NDR_IN) {
26457                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26458                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26459                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
26460                 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));
26461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26462                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26465                 if (r->in.buffer) {
26466                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26467                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26468                 }
26469         }
26470         if (flags & NDR_OUT) {
26471                 if (r->out.handle == NULL) {
26472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26473                 }
26474                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26475                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26476         }
26477         return NDR_ERR_SUCCESS;
26478 }
26479
26480 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
26481 {
26482         uint32_t _ptr_buffer;
26483         TALLOC_CTX *_mem_save_buffer_0;
26484         TALLOC_CTX *_mem_save_handle_0;
26485         if (flags & NDR_IN) {
26486                 ZERO_STRUCT(r->out);
26487
26488                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
26489                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
26490                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
26491                         return 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));
26492                 }
26493                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
26494                 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));
26495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26496                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26497                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26498                 if (r->in.bufsize > 512) {
26499                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26500                 }
26501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26502                 if (_ptr_buffer) {
26503                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26504                 } else {
26505                         r->in.buffer = NULL;
26506                 }
26507                 if (r->in.buffer) {
26508                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26509                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26511                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26512                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26514                 }
26515                 NDR_PULL_ALLOC(ndr, r->out.handle);
26516                 ZERO_STRUCTP(r->out.handle);
26517                 if (r->in.buffer) {
26518                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26519                 }
26520         }
26521         if (flags & NDR_OUT) {
26522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26523                         NDR_PULL_ALLOC(ndr, r->out.handle);
26524                 }
26525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26529                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26530         }
26531         return NDR_ERR_SUCCESS;
26532 }
26533
26534 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
26535 {
26536         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
26537         ndr->depth++;
26538         if (flags & NDR_SET_VALUES) {
26539                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26540         }
26541         if (flags & NDR_IN) {
26542                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
26543                 ndr->depth++;
26544                 ndr_print_string(ndr, "server_name", r->in.server_name);
26545                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
26546                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26547                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26548                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26549                 ndr->depth++;
26550                 if (r->in.buffer) {
26551                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26552                 }
26553                 ndr->depth--;
26554                 ndr->depth--;
26555         }
26556         if (flags & NDR_OUT) {
26557                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
26558                 ndr->depth++;
26559                 ndr_print_ptr(ndr, "handle", r->out.handle);
26560                 ndr->depth++;
26561                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26562                 ndr->depth--;
26563                 ndr_print_WERROR(ndr, "result", r->out.result);
26564                 ndr->depth--;
26565         }
26566         ndr->depth--;
26567 }
26568
26569 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
26570 {
26571         if (flags & NDR_IN) {
26572                 if (r->in.handle == NULL) {
26573                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26574                 }
26575                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26576                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
26578                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
26579                 if (r->in.buffer) {
26580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.bufsize));
26581                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
26582                 }
26583         }
26584         if (flags & NDR_OUT) {
26585                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26586         }
26587         return NDR_ERR_SUCCESS;
26588 }
26589
26590 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
26591 {
26592         uint32_t _ptr_buffer;
26593         TALLOC_CTX *_mem_save_handle_0;
26594         TALLOC_CTX *_mem_save_buffer_0;
26595         if (flags & NDR_IN) {
26596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26597                         NDR_PULL_ALLOC(ndr, r->in.handle);
26598                 }
26599                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26600                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26601                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26603                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
26605                 if (r->in.bufsize > 512) {
26606                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
26607                 }
26608                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
26609                 if (_ptr_buffer) {
26610                         NDR_PULL_ALLOC(ndr, r->in.buffer);
26611                 } else {
26612                         r->in.buffer = NULL;
26613                 }
26614                 if (r->in.buffer) {
26615                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26616                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
26617                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26618                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26619                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
26621                 }
26622                 if (r->in.buffer) {
26623                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
26624                 }
26625         }
26626         if (flags & NDR_OUT) {
26627                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26628         }
26629         return NDR_ERR_SUCCESS;
26630 }
26631
26632 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
26633 {
26634         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
26635         ndr->depth++;
26636         if (flags & NDR_SET_VALUES) {
26637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26638         }
26639         if (flags & NDR_IN) {
26640                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
26641                 ndr->depth++;
26642                 ndr_print_ptr(ndr, "handle", r->in.handle);
26643                 ndr->depth++;
26644                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26645                 ndr->depth--;
26646                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
26647                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
26648                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26649                 ndr->depth++;
26650                 if (r->in.buffer) {
26651                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
26652                 }
26653                 ndr->depth--;
26654                 ndr->depth--;
26655         }
26656         if (flags & NDR_OUT) {
26657                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
26658                 ndr->depth++;
26659                 ndr_print_WERROR(ndr, "result", r->out.result);
26660                 ndr->depth--;
26661         }
26662         ndr->depth--;
26663 }
26664
26665 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
26666 {
26667         if (flags & NDR_IN) {
26668                 if (r->in.handle == NULL) {
26669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26670                 }
26671                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26672         }
26673         if (flags & NDR_OUT) {
26674                 if (r->out.handle == NULL) {
26675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26676                 }
26677                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26678                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26679         }
26680         return NDR_ERR_SUCCESS;
26681 }
26682
26683 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
26684 {
26685         TALLOC_CTX *_mem_save_handle_0;
26686         if (flags & NDR_IN) {
26687                 ZERO_STRUCT(r->out);
26688
26689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26690                         NDR_PULL_ALLOC(ndr, r->in.handle);
26691                 }
26692                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26693                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26694                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26696                 NDR_PULL_ALLOC(ndr, r->out.handle);
26697                 *r->out.handle = *r->in.handle;
26698         }
26699         if (flags & NDR_OUT) {
26700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26701                         NDR_PULL_ALLOC(ndr, r->out.handle);
26702                 }
26703                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
26705                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
26706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26708         }
26709         return NDR_ERR_SUCCESS;
26710 }
26711
26712 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
26713 {
26714         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
26715         ndr->depth++;
26716         if (flags & NDR_SET_VALUES) {
26717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26718         }
26719         if (flags & NDR_IN) {
26720                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
26721                 ndr->depth++;
26722                 ndr_print_ptr(ndr, "handle", r->in.handle);
26723                 ndr->depth++;
26724                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26725                 ndr->depth--;
26726                 ndr->depth--;
26727         }
26728         if (flags & NDR_OUT) {
26729                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
26730                 ndr->depth++;
26731                 ndr_print_ptr(ndr, "handle", r->out.handle);
26732                 ndr->depth++;
26733                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
26734                 ndr->depth--;
26735                 ndr_print_WERROR(ndr, "result", r->out.result);
26736                 ndr->depth--;
26737         }
26738         ndr->depth--;
26739 }
26740
26741 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
26742 {
26743         if (flags & NDR_IN) {
26744         }
26745         if (flags & NDR_OUT) {
26746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26747         }
26748         return NDR_ERR_SUCCESS;
26749 }
26750
26751 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
26752 {
26753         if (flags & NDR_IN) {
26754         }
26755         if (flags & NDR_OUT) {
26756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26757         }
26758         return NDR_ERR_SUCCESS;
26759 }
26760
26761 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
26762 {
26763         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
26764         ndr->depth++;
26765         if (flags & NDR_SET_VALUES) {
26766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26767         }
26768         if (flags & NDR_IN) {
26769                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
26770                 ndr->depth++;
26771                 ndr->depth--;
26772         }
26773         if (flags & NDR_OUT) {
26774                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
26775                 ndr->depth++;
26776                 ndr_print_WERROR(ndr, "result", r->out.result);
26777                 ndr->depth--;
26778         }
26779         ndr->depth--;
26780 }
26781
26782 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26783 {
26784         if (flags & NDR_IN) {
26785         }
26786         if (flags & NDR_OUT) {
26787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26788         }
26789         return NDR_ERR_SUCCESS;
26790 }
26791
26792 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26793 {
26794         if (flags & NDR_IN) {
26795         }
26796         if (flags & NDR_OUT) {
26797                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26798         }
26799         return NDR_ERR_SUCCESS;
26800 }
26801
26802 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
26803 {
26804         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
26805         ndr->depth++;
26806         if (flags & NDR_SET_VALUES) {
26807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26808         }
26809         if (flags & NDR_IN) {
26810                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
26811                 ndr->depth++;
26812                 ndr->depth--;
26813         }
26814         if (flags & NDR_OUT) {
26815                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
26816                 ndr->depth++;
26817                 ndr_print_WERROR(ndr, "result", r->out.result);
26818                 ndr->depth--;
26819         }
26820         ndr->depth--;
26821 }
26822
26823 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
26824 {
26825         if (flags & NDR_IN) {
26826         }
26827         if (flags & NDR_OUT) {
26828                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26829         }
26830         return NDR_ERR_SUCCESS;
26831 }
26832
26833 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
26834 {
26835         if (flags & NDR_IN) {
26836         }
26837         if (flags & NDR_OUT) {
26838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26839         }
26840         return NDR_ERR_SUCCESS;
26841 }
26842
26843 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
26844 {
26845         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
26846         ndr->depth++;
26847         if (flags & NDR_SET_VALUES) {
26848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26849         }
26850         if (flags & NDR_IN) {
26851                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
26852                 ndr->depth++;
26853                 ndr->depth--;
26854         }
26855         if (flags & NDR_OUT) {
26856                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
26857                 ndr->depth++;
26858                 ndr_print_WERROR(ndr, "result", r->out.result);
26859                 ndr->depth--;
26860         }
26861         ndr->depth--;
26862 }
26863
26864 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
26865 {
26866         if (flags & NDR_IN) {
26867         }
26868         if (flags & NDR_OUT) {
26869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26870         }
26871         return NDR_ERR_SUCCESS;
26872 }
26873
26874 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
26875 {
26876         if (flags & NDR_IN) {
26877         }
26878         if (flags & NDR_OUT) {
26879                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26880         }
26881         return NDR_ERR_SUCCESS;
26882 }
26883
26884 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
26885 {
26886         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
26887         ndr->depth++;
26888         if (flags & NDR_SET_VALUES) {
26889                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26890         }
26891         if (flags & NDR_IN) {
26892                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
26893                 ndr->depth++;
26894                 ndr->depth--;
26895         }
26896         if (flags & NDR_OUT) {
26897                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
26898                 ndr->depth++;
26899                 ndr_print_WERROR(ndr, "result", r->out.result);
26900                 ndr->depth--;
26901         }
26902         ndr->depth--;
26903 }
26904
26905 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26906 {
26907         if (flags & NDR_IN) {
26908                 if (r->in.handle == NULL) {
26909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26910                 }
26911                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26912                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
26913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
26914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
26915                 if (r->in.local_machine) {
26916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
26918                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
26919                         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));
26920                 }
26921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
26922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
26923                 if (r->in.notify_options) {
26924                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26925                 }
26926         }
26927         if (flags & NDR_OUT) {
26928                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26929         }
26930         return NDR_ERR_SUCCESS;
26931 }
26932
26933 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26934 {
26935         uint32_t _ptr_local_machine;
26936         uint32_t _ptr_notify_options;
26937         TALLOC_CTX *_mem_save_handle_0;
26938         TALLOC_CTX *_mem_save_local_machine_0;
26939         TALLOC_CTX *_mem_save_notify_options_0;
26940         if (flags & NDR_IN) {
26941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26942                         NDR_PULL_ALLOC(ndr, r->in.handle);
26943                 }
26944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26948                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
26949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
26950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
26951                 if (_ptr_local_machine) {
26952                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
26953                 } else {
26954                         r->in.local_machine = NULL;
26955                 }
26956                 if (r->in.local_machine) {
26957                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
26958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
26959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
26960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
26961                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
26962                                 return 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));
26963                         }
26964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
26965                         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));
26966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
26967                 }
26968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
26969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
26970                 if (_ptr_notify_options) {
26971                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
26972                 } else {
26973                         r->in.notify_options = NULL;
26974                 }
26975                 if (r->in.notify_options) {
26976                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
26977                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
26978                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
26979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
26980                 }
26981         }
26982         if (flags & NDR_OUT) {
26983                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26984         }
26985         return NDR_ERR_SUCCESS;
26986 }
26987
26988 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
26989 {
26990         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26991         ndr->depth++;
26992         if (flags & NDR_SET_VALUES) {
26993                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26994         }
26995         if (flags & NDR_IN) {
26996                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
26997                 ndr->depth++;
26998                 ndr_print_ptr(ndr, "handle", r->in.handle);
26999                 ndr->depth++;
27000                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27001                 ndr->depth--;
27002                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27003                 ndr_print_uint32(ndr, "options", r->in.options);
27004                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
27005                 ndr->depth++;
27006                 if (r->in.local_machine) {
27007                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
27008                 }
27009                 ndr->depth--;
27010                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
27011                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
27012                 ndr->depth++;
27013                 if (r->in.notify_options) {
27014                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
27015                 }
27016                 ndr->depth--;
27017                 ndr->depth--;
27018         }
27019         if (flags & NDR_OUT) {
27020                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
27021                 ndr->depth++;
27022                 ndr_print_WERROR(ndr, "result", r->out.result);
27023                 ndr->depth--;
27024         }
27025         ndr->depth--;
27026 }
27027
27028 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27029 {
27030         if (flags & NDR_IN) {
27031                 if (r->in.handle == NULL) {
27032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27033                 }
27034                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
27036                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
27037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
27038                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27039                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27040         }
27041         if (flags & NDR_OUT) {
27042                 if (r->out.reply_result == NULL) {
27043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27044                 }
27045                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
27046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27047         }
27048         return NDR_ERR_SUCCESS;
27049 }
27050
27051 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
27052 {
27053         TALLOC_CTX *_mem_save_handle_0;
27054         TALLOC_CTX *_mem_save_reply_result_0;
27055         if (flags & NDR_IN) {
27056                 ZERO_STRUCT(r->out);
27057
27058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27059                         NDR_PULL_ALLOC(ndr, r->in.handle);
27060                 }
27061                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27062                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27063                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
27066                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
27067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
27068                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
27069                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
27070                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
27071                 ZERO_STRUCTP(r->out.reply_result);
27072         }
27073         if (flags & NDR_OUT) {
27074                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27075                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
27076                 }
27077                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
27078                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
27079                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
27080                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
27081                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27082         }
27083         return NDR_ERR_SUCCESS;
27084 }
27085
27086 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
27087 {
27088         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
27089         ndr->depth++;
27090         if (flags & NDR_SET_VALUES) {
27091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27092         }
27093         if (flags & NDR_IN) {
27094                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
27095                 ndr->depth++;
27096                 ndr_print_ptr(ndr, "handle", r->in.handle);
27097                 ndr->depth++;
27098                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27099                 ndr->depth--;
27100                 ndr_print_uint32(ndr, "color", r->in.color);
27101                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
27102                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
27103                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
27104                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
27105                 ndr->depth--;
27106         }
27107         if (flags & NDR_OUT) {
27108                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
27109                 ndr->depth++;
27110                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
27111                 ndr->depth++;
27112                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
27113                 ndr->depth--;
27114                 ndr_print_WERROR(ndr, "result", r->out.result);
27115                 ndr->depth--;
27116         }
27117         ndr->depth--;
27118 }
27119
27120 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27121 {
27122         if (flags & NDR_IN) {
27123                 if (r->in.handle == NULL) {
27124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27125                 }
27126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
27128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
27129                 if (r->in.options) {
27130                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27131                 }
27132         }
27133         if (flags & NDR_OUT) {
27134                 if (r->out.info == NULL) {
27135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27136                 }
27137                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
27138                 if (*r->out.info) {
27139                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27140                 }
27141                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27142         }
27143         return NDR_ERR_SUCCESS;
27144 }
27145
27146 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
27147 {
27148         uint32_t _ptr_options;
27149         uint32_t _ptr_info;
27150         TALLOC_CTX *_mem_save_handle_0;
27151         TALLOC_CTX *_mem_save_options_0;
27152         TALLOC_CTX *_mem_save_info_0;
27153         TALLOC_CTX *_mem_save_info_1;
27154         if (flags & NDR_IN) {
27155                 ZERO_STRUCT(r->out);
27156
27157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27158                         NDR_PULL_ALLOC(ndr, r->in.handle);
27159                 }
27160                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27162                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
27165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
27166                 if (_ptr_options) {
27167                         NDR_PULL_ALLOC(ndr, r->in.options);
27168                 } else {
27169                         r->in.options = NULL;
27170                 }
27171                 if (r->in.options) {
27172                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
27173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
27174                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
27175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
27176                 }
27177                 NDR_PULL_ALLOC(ndr, r->out.info);
27178                 ZERO_STRUCTP(r->out.info);
27179         }
27180         if (flags & NDR_OUT) {
27181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27182                         NDR_PULL_ALLOC(ndr, r->out.info);
27183                 }
27184                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
27185                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
27186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
27187                 if (_ptr_info) {
27188                         NDR_PULL_ALLOC(ndr, *r->out.info);
27189                 } else {
27190                         *r->out.info = NULL;
27191                 }
27192                 if (*r->out.info) {
27193                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
27194                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
27195                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
27196                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
27197                 }
27198                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
27199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27200         }
27201         return NDR_ERR_SUCCESS;
27202 }
27203
27204 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
27205 {
27206         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
27207         ndr->depth++;
27208         if (flags & NDR_SET_VALUES) {
27209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27210         }
27211         if (flags & NDR_IN) {
27212                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
27213                 ndr->depth++;
27214                 ndr_print_ptr(ndr, "handle", r->in.handle);
27215                 ndr->depth++;
27216                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27217                 ndr->depth--;
27218                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
27219                 ndr_print_ptr(ndr, "options", r->in.options);
27220                 ndr->depth++;
27221                 if (r->in.options) {
27222                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
27223                 }
27224                 ndr->depth--;
27225                 ndr->depth--;
27226         }
27227         if (flags & NDR_OUT) {
27228                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
27229                 ndr->depth++;
27230                 ndr_print_ptr(ndr, "info", r->out.info);
27231                 ndr->depth++;
27232                 ndr_print_ptr(ndr, "info", *r->out.info);
27233                 ndr->depth++;
27234                 if (*r->out.info) {
27235                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
27236                 }
27237                 ndr->depth--;
27238                 ndr->depth--;
27239                 ndr_print_WERROR(ndr, "result", r->out.result);
27240                 ndr->depth--;
27241         }
27242         ndr->depth--;
27243 }
27244
27245 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
27246 {
27247         if (flags & NDR_IN) {
27248         }
27249         if (flags & NDR_OUT) {
27250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27251         }
27252         return NDR_ERR_SUCCESS;
27253 }
27254
27255 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
27256 {
27257         if (flags & NDR_IN) {
27258         }
27259         if (flags & NDR_OUT) {
27260                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27261         }
27262         return NDR_ERR_SUCCESS;
27263 }
27264
27265 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
27266 {
27267         ndr_print_struct(ndr, name, "spoolss_44");
27268         ndr->depth++;
27269         if (flags & NDR_SET_VALUES) {
27270                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27271         }
27272         if (flags & NDR_IN) {
27273                 ndr_print_struct(ndr, "in", "spoolss_44");
27274                 ndr->depth++;
27275                 ndr->depth--;
27276         }
27277         if (flags & NDR_OUT) {
27278                 ndr_print_struct(ndr, "out", "spoolss_44");
27279                 ndr->depth++;
27280                 ndr_print_WERROR(ndr, "result", r->out.result);
27281                 ndr->depth--;
27282         }
27283         ndr->depth--;
27284 }
27285
27286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
27287 {
27288         if (flags & NDR_IN) {
27289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
27290                 if (r->in.printername) {
27291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27293                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
27294                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27295                 }
27296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
27297                 if (r->in.datatype) {
27298                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
27301                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27302                 }
27303                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27304                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
27305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
27306                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27307                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27308         }
27309         if (flags & NDR_OUT) {
27310                 if (r->out.handle == NULL) {
27311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27312                 }
27313                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27314                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27315         }
27316         return NDR_ERR_SUCCESS;
27317 }
27318
27319 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
27320 {
27321         uint32_t _ptr_printername;
27322         uint32_t _ptr_datatype;
27323         TALLOC_CTX *_mem_save_printername_0;
27324         TALLOC_CTX *_mem_save_datatype_0;
27325         TALLOC_CTX *_mem_save_handle_0;
27326         if (flags & NDR_IN) {
27327                 ZERO_STRUCT(r->out);
27328
27329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
27330                 if (_ptr_printername) {
27331                         NDR_PULL_ALLOC(ndr, r->in.printername);
27332                 } else {
27333                         r->in.printername = NULL;
27334                 }
27335                 if (r->in.printername) {
27336                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27337                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
27338                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
27339                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
27340                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
27341                                 return 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));
27342                         }
27343                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
27344                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
27345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
27346                 }
27347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
27348                 if (_ptr_datatype) {
27349                         NDR_PULL_ALLOC(ndr, r->in.datatype);
27350                 } else {
27351                         r->in.datatype = NULL;
27352                 }
27353                 if (r->in.datatype) {
27354                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
27355                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
27356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
27357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
27358                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
27359                                 return 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));
27360                         }
27361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
27362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
27363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
27364                 }
27365                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
27366                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
27367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
27368                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
27369                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
27370                 NDR_PULL_ALLOC(ndr, r->out.handle);
27371                 ZERO_STRUCTP(r->out.handle);
27372         }
27373         if (flags & NDR_OUT) {
27374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27375                         NDR_PULL_ALLOC(ndr, r->out.handle);
27376                 }
27377                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27378                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27379                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27381                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27382         }
27383         return NDR_ERR_SUCCESS;
27384 }
27385
27386 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
27387 {
27388         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
27389         ndr->depth++;
27390         if (flags & NDR_SET_VALUES) {
27391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27392         }
27393         if (flags & NDR_IN) {
27394                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
27395                 ndr->depth++;
27396                 ndr_print_ptr(ndr, "printername", r->in.printername);
27397                 ndr->depth++;
27398                 if (r->in.printername) {
27399                         ndr_print_string(ndr, "printername", r->in.printername);
27400                 }
27401                 ndr->depth--;
27402                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
27403                 ndr->depth++;
27404                 if (r->in.datatype) {
27405                         ndr_print_string(ndr, "datatype", r->in.datatype);
27406                 }
27407                 ndr->depth--;
27408                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
27409                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
27410                 ndr_print_uint32(ndr, "level", r->in.level);
27411                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
27412                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
27413                 ndr->depth--;
27414         }
27415         if (flags & NDR_OUT) {
27416                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
27417                 ndr->depth++;
27418                 ndr_print_ptr(ndr, "handle", r->out.handle);
27419                 ndr->depth++;
27420                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27421                 ndr->depth--;
27422                 ndr_print_WERROR(ndr, "result", r->out.result);
27423                 ndr->depth--;
27424         }
27425         ndr->depth--;
27426 }
27427
27428 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
27429 {
27430         if (flags & NDR_IN) {
27431                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27432                 if (r->in.server) {
27433                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27434                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27435                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27436                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27437                 }
27438                 if (r->in.info_ctr == NULL) {
27439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27440                 }
27441                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27442                 if (r->in.devmode_ctr == NULL) {
27443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27444                 }
27445                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27446                 if (r->in.secdesc_ctr == NULL) {
27447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27448                 }
27449                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27450                 if (r->in.userlevel_ctr == NULL) {
27451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27452                 }
27453                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27454         }
27455         if (flags & NDR_OUT) {
27456                 if (r->out.handle == NULL) {
27457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27458                 }
27459                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27461         }
27462         return NDR_ERR_SUCCESS;
27463 }
27464
27465 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
27466 {
27467         uint32_t _ptr_server;
27468         TALLOC_CTX *_mem_save_server_0;
27469         TALLOC_CTX *_mem_save_info_ctr_0;
27470         TALLOC_CTX *_mem_save_devmode_ctr_0;
27471         TALLOC_CTX *_mem_save_secdesc_ctr_0;
27472         TALLOC_CTX *_mem_save_userlevel_ctr_0;
27473         TALLOC_CTX *_mem_save_handle_0;
27474         if (flags & NDR_IN) {
27475                 ZERO_STRUCT(r->out);
27476
27477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27478                 if (_ptr_server) {
27479                         NDR_PULL_ALLOC(ndr, r->in.server);
27480                 } else {
27481                         r->in.server = NULL;
27482                 }
27483                 if (r->in.server) {
27484                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27485                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27488                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27489                                 return 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));
27490                         }
27491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27494                 }
27495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27496                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27497                 }
27498                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27499                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27500                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27501                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27502                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27503                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
27504                 }
27505                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27506                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
27507                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
27508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27509                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27510                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
27511                 }
27512                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27513                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
27514                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
27515                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27516                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27517                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
27518                 }
27519                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27520                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
27521                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
27522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27523                 NDR_PULL_ALLOC(ndr, r->out.handle);
27524                 ZERO_STRUCTP(r->out.handle);
27525         }
27526         if (flags & NDR_OUT) {
27527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27528                         NDR_PULL_ALLOC(ndr, r->out.handle);
27529                 }
27530                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27531                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
27532                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
27533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27535         }
27536         return NDR_ERR_SUCCESS;
27537 }
27538
27539 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
27540 {
27541         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
27542         ndr->depth++;
27543         if (flags & NDR_SET_VALUES) {
27544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27545         }
27546         if (flags & NDR_IN) {
27547                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
27548                 ndr->depth++;
27549                 ndr_print_ptr(ndr, "server", r->in.server);
27550                 ndr->depth++;
27551                 if (r->in.server) {
27552                         ndr_print_string(ndr, "server", r->in.server);
27553                 }
27554                 ndr->depth--;
27555                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27556                 ndr->depth++;
27557                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27558                 ndr->depth--;
27559                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
27560                 ndr->depth++;
27561                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
27562                 ndr->depth--;
27563                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27564                 ndr->depth++;
27565                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
27566                 ndr->depth--;
27567                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27568                 ndr->depth++;
27569                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
27570                 ndr->depth--;
27571                 ndr->depth--;
27572         }
27573         if (flags & NDR_OUT) {
27574                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
27575                 ndr->depth++;
27576                 ndr_print_ptr(ndr, "handle", r->out.handle);
27577                 ndr->depth++;
27578                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
27579                 ndr->depth--;
27580                 ndr_print_WERROR(ndr, "result", r->out.result);
27581                 ndr->depth--;
27582         }
27583         ndr->depth--;
27584 }
27585
27586 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
27587 {
27588         if (flags & NDR_IN) {
27589         }
27590         if (flags & NDR_OUT) {
27591                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27592         }
27593         return NDR_ERR_SUCCESS;
27594 }
27595
27596 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
27597 {
27598         if (flags & NDR_IN) {
27599         }
27600         if (flags & NDR_OUT) {
27601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27602         }
27603         return NDR_ERR_SUCCESS;
27604 }
27605
27606 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
27607 {
27608         ndr_print_struct(ndr, name, "spoolss_47");
27609         ndr->depth++;
27610         if (flags & NDR_SET_VALUES) {
27611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27612         }
27613         if (flags & NDR_IN) {
27614                 ndr_print_struct(ndr, "in", "spoolss_47");
27615                 ndr->depth++;
27616                 ndr->depth--;
27617         }
27618         if (flags & NDR_OUT) {
27619                 ndr_print_struct(ndr, "out", "spoolss_47");
27620                 ndr->depth++;
27621                 ndr_print_WERROR(ndr, "result", r->out.result);
27622                 ndr->depth--;
27623         }
27624         ndr->depth--;
27625 }
27626
27627 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
27628 {
27629         if (flags & NDR_IN) {
27630                 if (r->in.handle == NULL) {
27631                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27632                 }
27633                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
27635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
27636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
27637         }
27638         if (flags & NDR_OUT) {
27639                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.value_offered / 2));
27640                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
27641                 if (r->out.value_needed == NULL) {
27642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27643                 }
27644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
27645                 if (r->out.type == NULL) {
27646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27647                 }
27648                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
27649                 {
27650                         uint32_t _flags_save_uint8 = ndr->flags;
27651                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27652                         if (r->out.data == NULL) {
27653                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27654                         }
27655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.data_offered));
27656                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
27657                         ndr->flags = _flags_save_uint8;
27658                 }
27659                 if (r->out.data_needed == NULL) {
27660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27661                 }
27662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
27663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27664         }
27665         return NDR_ERR_SUCCESS;
27666 }
27667
27668 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
27669 {
27670         TALLOC_CTX *_mem_save_handle_0;
27671         TALLOC_CTX *_mem_save_value_needed_0;
27672         TALLOC_CTX *_mem_save_type_0;
27673         TALLOC_CTX *_mem_save_data_needed_0;
27674         if (flags & NDR_IN) {
27675                 ZERO_STRUCT(r->out);
27676
27677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27678                         NDR_PULL_ALLOC(ndr, r->in.handle);
27679                 }
27680                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
27685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
27686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
27687                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
27688                 ZERO_STRUCTP(r->out.value_needed);
27689                 NDR_PULL_ALLOC(ndr, r->out.type);
27690                 ZERO_STRUCTP(r->out.type);
27691                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
27692                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
27693                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
27694                 ZERO_STRUCTP(r->out.data_needed);
27695         }
27696         if (flags & NDR_OUT) {
27697                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
27698                 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));
27699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27700                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
27701                 }
27702                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27703                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
27704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
27705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
27706                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27707                         NDR_PULL_ALLOC(ndr, r->out.type);
27708                 }
27709                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
27710                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
27711                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
27712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
27713                 {
27714                         uint32_t _flags_save_uint8 = ndr->flags;
27715                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
27716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
27717                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27718                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
27719                         }
27720                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
27721                         ndr->flags = _flags_save_uint8;
27722                 }
27723                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27724                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
27725                 }
27726                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27727                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
27728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
27729                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
27730                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27731                 if (r->out.value_name) {
27732                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
27733                 }
27734                 if (r->out.data) {
27735                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
27736                 }
27737         }
27738         return NDR_ERR_SUCCESS;
27739 }
27740
27741 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
27742 {
27743         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
27744         ndr->depth++;
27745         if (flags & NDR_SET_VALUES) {
27746                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27747         }
27748         if (flags & NDR_IN) {
27749                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
27750                 ndr->depth++;
27751                 ndr_print_ptr(ndr, "handle", r->in.handle);
27752                 ndr->depth++;
27753                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27754                 ndr->depth--;
27755                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
27756                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
27757                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
27758                 ndr->depth--;
27759         }
27760         if (flags & NDR_OUT) {
27761                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
27762                 ndr->depth++;
27763                 ndr_print_string(ndr, "value_name", r->out.value_name);
27764                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
27765                 ndr->depth++;
27766                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
27767                 ndr->depth--;
27768                 ndr_print_ptr(ndr, "type", r->out.type);
27769                 ndr->depth++;
27770                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
27771                 ndr->depth--;
27772                 ndr_print_ptr(ndr, "data", r->out.data);
27773                 ndr->depth++;
27774                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
27775                 ndr->depth--;
27776                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
27777                 ndr->depth++;
27778                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
27779                 ndr->depth--;
27780                 ndr_print_WERROR(ndr, "result", r->out.result);
27781                 ndr->depth--;
27782         }
27783         ndr->depth--;
27784 }
27785
27786 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
27787 {
27788         if (flags & NDR_IN) {
27789                 if (r->in.handle == NULL) {
27790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27791                 }
27792                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27793                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27794                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27795                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27796                 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));
27797         }
27798         if (flags & NDR_OUT) {
27799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27800         }
27801         return NDR_ERR_SUCCESS;
27802 }
27803
27804 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
27805 {
27806         TALLOC_CTX *_mem_save_handle_0;
27807         if (flags & NDR_IN) {
27808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27809                         NDR_PULL_ALLOC(ndr, r->in.handle);
27810                 }
27811                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27815                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
27816                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
27817                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
27818                         return 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));
27819                 }
27820                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
27821                 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));
27822         }
27823         if (flags & NDR_OUT) {
27824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27825         }
27826         return NDR_ERR_SUCCESS;
27827 }
27828
27829 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
27830 {
27831         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
27832         ndr->depth++;
27833         if (flags & NDR_SET_VALUES) {
27834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27835         }
27836         if (flags & NDR_IN) {
27837                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
27838                 ndr->depth++;
27839                 ndr_print_ptr(ndr, "handle", r->in.handle);
27840                 ndr->depth++;
27841                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27842                 ndr->depth--;
27843                 ndr_print_string(ndr, "value_name", r->in.value_name);
27844                 ndr->depth--;
27845         }
27846         if (flags & NDR_OUT) {
27847                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
27848                 ndr->depth++;
27849                 ndr_print_WERROR(ndr, "result", r->out.result);
27850                 ndr->depth--;
27851         }
27852         ndr->depth--;
27853 }
27854
27855 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
27856 {
27857         if (flags & NDR_IN) {
27858         }
27859         if (flags & NDR_OUT) {
27860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27861         }
27862         return NDR_ERR_SUCCESS;
27863 }
27864
27865 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
27866 {
27867         if (flags & NDR_IN) {
27868         }
27869         if (flags & NDR_OUT) {
27870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27871         }
27872         return NDR_ERR_SUCCESS;
27873 }
27874
27875 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
27876 {
27877         ndr_print_struct(ndr, name, "spoolss_4a");
27878         ndr->depth++;
27879         if (flags & NDR_SET_VALUES) {
27880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27881         }
27882         if (flags & NDR_IN) {
27883                 ndr_print_struct(ndr, "in", "spoolss_4a");
27884                 ndr->depth++;
27885                 ndr->depth--;
27886         }
27887         if (flags & NDR_OUT) {
27888                 ndr_print_struct(ndr, "out", "spoolss_4a");
27889                 ndr->depth++;
27890                 ndr_print_WERROR(ndr, "result", r->out.result);
27891                 ndr->depth--;
27892         }
27893         ndr->depth--;
27894 }
27895
27896 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
27897 {
27898         if (flags & NDR_IN) {
27899         }
27900         if (flags & NDR_OUT) {
27901                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27902         }
27903         return NDR_ERR_SUCCESS;
27904 }
27905
27906 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
27907 {
27908         if (flags & NDR_IN) {
27909         }
27910         if (flags & NDR_OUT) {
27911                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27912         }
27913         return NDR_ERR_SUCCESS;
27914 }
27915
27916 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
27917 {
27918         ndr_print_struct(ndr, name, "spoolss_4b");
27919         ndr->depth++;
27920         if (flags & NDR_SET_VALUES) {
27921                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27922         }
27923         if (flags & NDR_IN) {
27924                 ndr_print_struct(ndr, "in", "spoolss_4b");
27925                 ndr->depth++;
27926                 ndr->depth--;
27927         }
27928         if (flags & NDR_OUT) {
27929                 ndr_print_struct(ndr, "out", "spoolss_4b");
27930                 ndr->depth++;
27931                 ndr_print_WERROR(ndr, "result", r->out.result);
27932                 ndr->depth--;
27933         }
27934         ndr->depth--;
27935 }
27936
27937 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
27938 {
27939         if (flags & NDR_IN) {
27940         }
27941         if (flags & NDR_OUT) {
27942                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27943         }
27944         return NDR_ERR_SUCCESS;
27945 }
27946
27947 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
27948 {
27949         if (flags & NDR_IN) {
27950         }
27951         if (flags & NDR_OUT) {
27952                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27953         }
27954         return NDR_ERR_SUCCESS;
27955 }
27956
27957 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
27958 {
27959         ndr_print_struct(ndr, name, "spoolss_4c");
27960         ndr->depth++;
27961         if (flags & NDR_SET_VALUES) {
27962                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27963         }
27964         if (flags & NDR_IN) {
27965                 ndr_print_struct(ndr, "in", "spoolss_4c");
27966                 ndr->depth++;
27967                 ndr->depth--;
27968         }
27969         if (flags & NDR_OUT) {
27970                 ndr_print_struct(ndr, "out", "spoolss_4c");
27971                 ndr->depth++;
27972                 ndr_print_WERROR(ndr, "result", r->out.result);
27973                 ndr->depth--;
27974         }
27975         ndr->depth--;
27976 }
27977
27978 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterDataEx *r)
27979 {
27980         if (flags & NDR_IN) {
27981                 if (r->in.handle == NULL) {
27982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27983                 }
27984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27985                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27986                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27987                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
27988                 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));
27989                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27990                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
27991                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
27992                 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));
27993                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
27994                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
27995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
27996         }
27997         if (flags & NDR_OUT) {
27998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27999         }
28000         return NDR_ERR_SUCCESS;
28001 }
28002
28003 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterDataEx *r)
28004 {
28005         if (flags & NDR_IN) {
28006                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28007         }
28008         if (flags & NDR_OUT) {
28009                 if (r->out.data == NULL) {
28010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28011                 }
28012                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28013                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28014         }
28015         return NDR_ERR_SUCCESS;
28016 }
28017
28018 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
28019 {
28020         TALLOC_CTX *_mem_save_handle_0;
28021         if (flags & NDR_IN) {
28022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28023                         NDR_PULL_ALLOC(ndr, r->in.handle);
28024                 }
28025                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28026                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28027                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28029                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28030                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28031                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28032                         return 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));
28033                 }
28034                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28035                 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));
28036                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28037                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28038                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28039                         return 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));
28040                 }
28041                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28042                 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));
28043                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28044                 {
28045                         struct ndr_pull *_ndr_data;
28046                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
28047                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
28048                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
28049                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
28050                 }
28051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
28052         }
28053         if (flags & NDR_OUT) {
28054                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28055         }
28056         return NDR_ERR_SUCCESS;
28057 }
28058
28059 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
28060 {
28061         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
28062         ndr->depth++;
28063         if (flags & NDR_SET_VALUES) {
28064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28065         }
28066         if (flags & NDR_IN) {
28067                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
28068                 ndr->depth++;
28069                 ndr_print_ptr(ndr, "handle", r->in.handle);
28070                 ndr->depth++;
28071                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28072                 ndr->depth--;
28073                 ndr_print_string(ndr, "key_name", r->in.key_name);
28074                 ndr_print_string(ndr, "value_name", r->in.value_name);
28075                 ndr_print_winreg_Type(ndr, "type", r->in.type);
28076                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
28077                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
28078                 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);
28079                 ndr->depth--;
28080         }
28081         if (flags & NDR_OUT) {
28082                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
28083                 ndr->depth++;
28084                 ndr_print_WERROR(ndr, "result", r->out.result);
28085                 ndr->depth--;
28086         }
28087         ndr->depth--;
28088 }
28089
28090 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterDataEx *r)
28091 {
28092         if (flags & NDR_IN) {
28093                 if (r->in.handle == NULL) {
28094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28095                 }
28096                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28097                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28098                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28099                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28100                 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));
28101                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28102                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28103                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28104                 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));
28105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28106         }
28107         if (flags & NDR_OUT) {
28108                 if (r->out.type == NULL) {
28109                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28110                 }
28111                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
28112                 if (r->out.data == NULL) {
28113                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28114                 }
28115                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
28116                 if (r->out.needed == NULL) {
28117                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28118                 }
28119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28120                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28121         }
28122         return NDR_ERR_SUCCESS;
28123 }
28124
28125 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterDataEx *r)
28126 {
28127         TALLOC_CTX *_mem_save_handle_0;
28128         TALLOC_CTX *_mem_save_type_0;
28129         TALLOC_CTX *_mem_save_data_0;
28130         TALLOC_CTX *_mem_save_needed_0;
28131         if (flags & NDR_IN) {
28132                 ZERO_STRUCT(r->out);
28133
28134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28135                         NDR_PULL_ALLOC(ndr, r->in.handle);
28136                 }
28137                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28139                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28141                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28142                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28143                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28144                         return 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));
28145                 }
28146                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28147                 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));
28148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28149                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28150                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28151                         return 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));
28152                 }
28153                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28154                 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));
28155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28156                 NDR_PULL_ALLOC(ndr, r->out.type);
28157                 ZERO_STRUCTP(r->out.type);
28158                 NDR_PULL_ALLOC(ndr, r->out.data);
28159                 ZERO_STRUCTP(r->out.data);
28160                 NDR_PULL_ALLOC(ndr, r->out.needed);
28161                 ZERO_STRUCTP(r->out.needed);
28162         }
28163         if (flags & NDR_OUT) {
28164                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28165                         NDR_PULL_ALLOC(ndr, r->out.type);
28166                 }
28167                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
28168                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
28169                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
28170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
28171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28172                         NDR_PULL_ALLOC(ndr, r->out.data);
28173                 }
28174                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28175                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28176                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
28177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28178                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28179                         NDR_PULL_ALLOC(ndr, r->out.needed);
28180                 }
28181                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28182                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28185                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28186         }
28187         return NDR_ERR_SUCCESS;
28188 }
28189
28190 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterDataEx *r)
28191 {
28192         if (flags & NDR_IN) {
28193                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
28194         }
28195         if (flags & NDR_OUT) {
28196                 if (r->out.data == NULL) {
28197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28198                 }
28199                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
28200                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28201         }
28202         return NDR_ERR_SUCCESS;
28203 }
28204
28205 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterDataEx *r)
28206 {
28207         TALLOC_CTX *_mem_save_data_0;
28208         if (flags & NDR_IN) {
28209                 ZERO_STRUCT(r->out);
28210
28211                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
28212                 NDR_PULL_ALLOC(ndr, r->out.data);
28213                 ZERO_STRUCTP(r->out.data);
28214         }
28215         if (flags & NDR_OUT) {
28216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28217                         NDR_PULL_ALLOC(ndr, r->out.data);
28218                 }
28219                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
28220                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
28221                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
28222                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
28223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
28224         }
28225         return NDR_ERR_SUCCESS;
28226 }
28227
28228 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
28229 {
28230         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
28231         ndr->depth++;
28232         if (flags & NDR_SET_VALUES) {
28233                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28234         }
28235         if (flags & NDR_IN) {
28236                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
28237                 ndr->depth++;
28238                 ndr_print_ptr(ndr, "handle", r->in.handle);
28239                 ndr->depth++;
28240                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28241                 ndr->depth--;
28242                 ndr_print_string(ndr, "key_name", r->in.key_name);
28243                 ndr_print_string(ndr, "value_name", r->in.value_name);
28244                 ndr_print_uint32(ndr, "offered", r->in.offered);
28245                 ndr->depth--;
28246         }
28247         if (flags & NDR_OUT) {
28248                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
28249                 ndr->depth++;
28250                 ndr_print_ptr(ndr, "type", r->out.type);
28251                 ndr->depth++;
28252                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
28253                 ndr->depth--;
28254                 ndr_print_ptr(ndr, "data", r->out.data);
28255                 ndr->depth++;
28256                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
28257                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
28258                 ndr->depth--;
28259                 ndr_print_ptr(ndr, "needed", r->out.needed);
28260                 ndr->depth++;
28261                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28262                 ndr->depth--;
28263                 ndr_print_WERROR(ndr, "result", r->out.result);
28264                 ndr->depth--;
28265         }
28266         ndr->depth--;
28267 }
28268
28269 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
28270 {
28271         if (flags & NDR_IN) {
28272                 if (r->in.handle == NULL) {
28273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28274                 }
28275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28276                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28277                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28278                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28279                 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));
28280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28281         }
28282         if (flags & NDR_OUT) {
28283                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
28284                 if (r->out.needed == NULL) {
28285                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28286                 }
28287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28288                 if (r->out.count == NULL) {
28289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28290                 }
28291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
28292                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28293         }
28294         return NDR_ERR_SUCCESS;
28295 }
28296
28297 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
28298 {
28299         TALLOC_CTX *_mem_save_handle_0;
28300         TALLOC_CTX *_mem_save_needed_0;
28301         TALLOC_CTX *_mem_save_count_0;
28302         if (flags & NDR_IN) {
28303                 ZERO_STRUCT(r->out);
28304
28305                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28306                         NDR_PULL_ALLOC(ndr, r->in.handle);
28307                 }
28308                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28309                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28310                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28311                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28312                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28313                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28314                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28315                         return 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));
28316                 }
28317                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28318                 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));
28319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28320                 NDR_PULL_ALLOC(ndr, r->out.needed);
28321                 ZERO_STRUCTP(r->out.needed);
28322                 NDR_PULL_ALLOC(ndr, r->out.count);
28323                 ZERO_STRUCTP(r->out.count);
28324         }
28325         if (flags & NDR_OUT) {
28326                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
28327                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28328                         NDR_PULL_ALLOC(ndr, r->out.needed);
28329                 }
28330                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28331                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28333                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28335                         NDR_PULL_ALLOC(ndr, r->out.count);
28336                 }
28337                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
28338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
28339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
28340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
28341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28342         }
28343         return NDR_ERR_SUCCESS;
28344 }
28345
28346 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
28347 {
28348         uint32_t cntr_info_0;
28349         if (flags & NDR_IN) {
28350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
28351         }
28352         if (flags & NDR_OUT) {
28353                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28354                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28355                 }
28356                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28357                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28358                 }
28359         }
28360         return NDR_ERR_SUCCESS;
28361 }
28362
28363 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
28364 {
28365         uint32_t cntr_info_0;
28366         TALLOC_CTX *_mem_save_info_0;
28367         if (flags & NDR_IN) {
28368                 ZERO_STRUCT(r->out);
28369
28370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
28371         }
28372         if (flags & NDR_OUT) {
28373                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
28374                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
28375                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
28376                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28377                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
28378                 }
28379                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
28380                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
28381                 }
28382                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
28383         }
28384         return NDR_ERR_SUCCESS;
28385 }
28386
28387 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
28388 {
28389         uint32_t cntr_info_2;
28390         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
28391         ndr->depth++;
28392         if (flags & NDR_SET_VALUES) {
28393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28394         }
28395         if (flags & NDR_IN) {
28396                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
28397                 ndr->depth++;
28398                 ndr_print_ptr(ndr, "handle", r->in.handle);
28399                 ndr->depth++;
28400                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28401                 ndr->depth--;
28402                 ndr_print_string(ndr, "key_name", r->in.key_name);
28403                 ndr_print_uint32(ndr, "offered", r->in.offered);
28404                 ndr->depth--;
28405         }
28406         if (flags & NDR_OUT) {
28407                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
28408                 ndr->depth++;
28409                 ndr_print_ptr(ndr, "count", r->out.count);
28410                 ndr->depth++;
28411                 ndr_print_uint32(ndr, "count", *r->out.count);
28412                 ndr->depth--;
28413                 ndr_print_ptr(ndr, "info", r->out.info);
28414                 ndr->depth++;
28415                 ndr_print_ptr(ndr, "info", *r->out.info);
28416                 ndr->depth++;
28417                 if (*r->out.info) {
28418                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
28419                         ndr->depth++;
28420                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
28421                                 char *idx_2=NULL;
28422                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
28423                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
28424                                         free(idx_2);
28425                                 }
28426                         }
28427                         ndr->depth--;
28428                 }
28429                 ndr->depth--;
28430                 ndr->depth--;
28431                 ndr_print_ptr(ndr, "needed", r->out.needed);
28432                 ndr->depth++;
28433                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28434                 ndr->depth--;
28435                 ndr_print_WERROR(ndr, "result", r->out.result);
28436                 ndr->depth--;
28437         }
28438         ndr->depth--;
28439 }
28440
28441 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
28442 {
28443         if (flags & NDR_IN) {
28444                 if (r->in.handle == NULL) {
28445                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28446                 }
28447                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28448                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28449                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28450                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28451                 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));
28452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
28453         }
28454         if (flags & NDR_OUT) {
28455                 if (r->out._ndr_size == NULL) {
28456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28457                 }
28458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
28459                 if (r->out.key_buffer == NULL) {
28460                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28461                 }
28462                 {
28463                         struct ndr_push *_ndr_key_buffer;
28464                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28465                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28466                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28467                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28468                 }
28469                 if (r->out.needed == NULL) {
28470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28471                 }
28472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
28473                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28474         }
28475         return NDR_ERR_SUCCESS;
28476 }
28477
28478 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
28479 {
28480         TALLOC_CTX *_mem_save_handle_0;
28481         TALLOC_CTX *_mem_save__ndr_size_0;
28482         TALLOC_CTX *_mem_save_key_buffer_0;
28483         TALLOC_CTX *_mem_save_needed_0;
28484         if (flags & NDR_IN) {
28485                 ZERO_STRUCT(r->out);
28486
28487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28488                         NDR_PULL_ALLOC(ndr, r->in.handle);
28489                 }
28490                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28494                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28495                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28496                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28497                         return 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));
28498                 }
28499                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28500                 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));
28501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
28502                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28503                 ZERO_STRUCTP(r->out._ndr_size);
28504                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28505                 ZERO_STRUCTP(r->out.key_buffer);
28506                 NDR_PULL_ALLOC(ndr, r->out.needed);
28507                 ZERO_STRUCTP(r->out.needed);
28508         }
28509         if (flags & NDR_OUT) {
28510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28511                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
28512                 }
28513                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
28514                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
28515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
28516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
28517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28518                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
28519                 }
28520                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
28521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
28522                 {
28523                         struct ndr_pull *_ndr_key_buffer;
28524                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
28525                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
28526                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
28527                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
28528                 }
28529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
28530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28531                         NDR_PULL_ALLOC(ndr, r->out.needed);
28532                 }
28533                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
28534                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
28535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
28536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
28537                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28538         }
28539         return NDR_ERR_SUCCESS;
28540 }
28541
28542 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
28543 {
28544         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
28545         ndr->depth++;
28546         if (flags & NDR_SET_VALUES) {
28547                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28548         }
28549         if (flags & NDR_IN) {
28550                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
28551                 ndr->depth++;
28552                 ndr_print_ptr(ndr, "handle", r->in.handle);
28553                 ndr->depth++;
28554                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28555                 ndr->depth--;
28556                 ndr_print_string(ndr, "key_name", r->in.key_name);
28557                 ndr_print_uint32(ndr, "offered", r->in.offered);
28558                 ndr->depth--;
28559         }
28560         if (flags & NDR_OUT) {
28561                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
28562                 ndr->depth++;
28563                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
28564                 ndr->depth++;
28565                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
28566                 ndr->depth--;
28567                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
28568                 ndr->depth++;
28569                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
28570                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
28571                 ndr->depth--;
28572                 ndr_print_ptr(ndr, "needed", r->out.needed);
28573                 ndr->depth++;
28574                 ndr_print_uint32(ndr, "needed", *r->out.needed);
28575                 ndr->depth--;
28576                 ndr_print_WERROR(ndr, "result", r->out.result);
28577                 ndr->depth--;
28578         }
28579         ndr->depth--;
28580 }
28581
28582 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
28583 {
28584         if (flags & NDR_IN) {
28585                 if (r->in.handle == NULL) {
28586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28587                 }
28588                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.key_name, ndr_charset_length(r->in.key_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28593                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28594                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28595                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
28596                 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));
28597         }
28598         if (flags & NDR_OUT) {
28599                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28600         }
28601         return NDR_ERR_SUCCESS;
28602 }
28603
28604 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
28605 {
28606         TALLOC_CTX *_mem_save_handle_0;
28607         if (flags & NDR_IN) {
28608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28609                         NDR_PULL_ALLOC(ndr, r->in.handle);
28610                 }
28611                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28615                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28616                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28617                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28618                         return 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));
28619                 }
28620                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28621                 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));
28622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
28623                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
28624                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
28625                         return 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));
28626                 }
28627                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
28628                 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));
28629         }
28630         if (flags & NDR_OUT) {
28631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28632         }
28633         return NDR_ERR_SUCCESS;
28634 }
28635
28636 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
28637 {
28638         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
28639         ndr->depth++;
28640         if (flags & NDR_SET_VALUES) {
28641                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28642         }
28643         if (flags & NDR_IN) {
28644                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
28645                 ndr->depth++;
28646                 ndr_print_ptr(ndr, "handle", r->in.handle);
28647                 ndr->depth++;
28648                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28649                 ndr->depth--;
28650                 ndr_print_string(ndr, "key_name", r->in.key_name);
28651                 ndr_print_string(ndr, "value_name", r->in.value_name);
28652                 ndr->depth--;
28653         }
28654         if (flags & NDR_OUT) {
28655                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
28656                 ndr->depth++;
28657                 ndr_print_WERROR(ndr, "result", r->out.result);
28658                 ndr->depth--;
28659         }
28660         ndr->depth--;
28661 }
28662
28663 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
28664 {
28665         if (flags & NDR_IN) {
28666                 if (r->in.handle == NULL) {
28667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
28668                 }
28669                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28670                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28671                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28672                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
28673                 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));
28674         }
28675         if (flags & NDR_OUT) {
28676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28677         }
28678         return NDR_ERR_SUCCESS;
28679 }
28680
28681 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
28682 {
28683         TALLOC_CTX *_mem_save_handle_0;
28684         if (flags & NDR_IN) {
28685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
28686                         NDR_PULL_ALLOC(ndr, r->in.handle);
28687                 }
28688                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
28689                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
28690                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
28691                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
28692                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
28693                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
28694                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
28695                         return 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));
28696                 }
28697                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
28698                 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));
28699         }
28700         if (flags & NDR_OUT) {
28701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28702         }
28703         return NDR_ERR_SUCCESS;
28704 }
28705
28706 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
28707 {
28708         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
28709         ndr->depth++;
28710         if (flags & NDR_SET_VALUES) {
28711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28712         }
28713         if (flags & NDR_IN) {
28714                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
28715                 ndr->depth++;
28716                 ndr_print_ptr(ndr, "handle", r->in.handle);
28717                 ndr->depth++;
28718                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
28719                 ndr->depth--;
28720                 ndr_print_string(ndr, "key_name", r->in.key_name);
28721                 ndr->depth--;
28722         }
28723         if (flags & NDR_OUT) {
28724                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
28725                 ndr->depth++;
28726                 ndr_print_WERROR(ndr, "result", r->out.result);
28727                 ndr->depth--;
28728         }
28729         ndr->depth--;
28730 }
28731
28732 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
28733 {
28734         if (flags & NDR_IN) {
28735         }
28736         if (flags & NDR_OUT) {
28737                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28738         }
28739         return NDR_ERR_SUCCESS;
28740 }
28741
28742 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
28743 {
28744         if (flags & NDR_IN) {
28745         }
28746         if (flags & NDR_OUT) {
28747                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28748         }
28749         return NDR_ERR_SUCCESS;
28750 }
28751
28752 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
28753 {
28754         ndr_print_struct(ndr, name, "spoolss_53");
28755         ndr->depth++;
28756         if (flags & NDR_SET_VALUES) {
28757                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28758         }
28759         if (flags & NDR_IN) {
28760                 ndr_print_struct(ndr, "in", "spoolss_53");
28761                 ndr->depth++;
28762                 ndr->depth--;
28763         }
28764         if (flags & NDR_OUT) {
28765                 ndr_print_struct(ndr, "out", "spoolss_53");
28766                 ndr->depth++;
28767                 ndr_print_WERROR(ndr, "result", r->out.result);
28768                 ndr->depth--;
28769         }
28770         ndr->depth--;
28771 }
28772
28773 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28774 {
28775         if (flags & NDR_IN) {
28776                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
28777                 if (r->in.server) {
28778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
28781                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28782                 }
28783                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28784                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28785                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
28786                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28787                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28788                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
28789                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
28790                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
28791                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
28792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
28793         }
28794         if (flags & NDR_OUT) {
28795                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28796         }
28797         return NDR_ERR_SUCCESS;
28798 }
28799
28800 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
28801 {
28802         uint32_t _ptr_server;
28803         TALLOC_CTX *_mem_save_server_0;
28804         if (flags & NDR_IN) {
28805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
28806                 if (_ptr_server) {
28807                         NDR_PULL_ALLOC(ndr, r->in.server);
28808                 } else {
28809                         r->in.server = NULL;
28810                 }
28811                 if (r->in.server) {
28812                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
28813                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
28814                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
28815                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
28816                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
28817                                 return 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));
28818                         }
28819                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
28820                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
28821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
28822                 }
28823                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
28824                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
28825                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
28826                         return 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));
28827                 }
28828                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
28829                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
28830                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
28831                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
28832                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
28833                         return 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));
28834                 }
28835                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
28836                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
28837                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
28838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
28839         }
28840         if (flags & NDR_OUT) {
28841                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28842         }
28843         return NDR_ERR_SUCCESS;
28844 }
28845
28846 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
28847 {
28848         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
28849         ndr->depth++;
28850         if (flags & NDR_SET_VALUES) {
28851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28852         }
28853         if (flags & NDR_IN) {
28854                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
28855                 ndr->depth++;
28856                 ndr_print_ptr(ndr, "server", r->in.server);
28857                 ndr->depth++;
28858                 if (r->in.server) {
28859                         ndr_print_string(ndr, "server", r->in.server);
28860                 }
28861                 ndr->depth--;
28862                 ndr_print_string(ndr, "architecture", r->in.architecture);
28863                 ndr_print_string(ndr, "driver", r->in.driver);
28864                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
28865                 ndr_print_uint32(ndr, "version", r->in.version);
28866                 ndr->depth--;
28867         }
28868         if (flags & NDR_OUT) {
28869                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
28870                 ndr->depth++;
28871                 ndr_print_WERROR(ndr, "result", r->out.result);
28872                 ndr->depth--;
28873         }
28874         ndr->depth--;
28875 }
28876
28877 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
28878 {
28879         if (flags & NDR_IN) {
28880         }
28881         if (flags & NDR_OUT) {
28882                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28883         }
28884         return NDR_ERR_SUCCESS;
28885 }
28886
28887 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
28888 {
28889         if (flags & NDR_IN) {
28890         }
28891         if (flags & NDR_OUT) {
28892                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28893         }
28894         return NDR_ERR_SUCCESS;
28895 }
28896
28897 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
28898 {
28899         ndr_print_struct(ndr, name, "spoolss_55");
28900         ndr->depth++;
28901         if (flags & NDR_SET_VALUES) {
28902                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28903         }
28904         if (flags & NDR_IN) {
28905                 ndr_print_struct(ndr, "in", "spoolss_55");
28906                 ndr->depth++;
28907                 ndr->depth--;
28908         }
28909         if (flags & NDR_OUT) {
28910                 ndr_print_struct(ndr, "out", "spoolss_55");
28911                 ndr->depth++;
28912                 ndr_print_WERROR(ndr, "result", r->out.result);
28913                 ndr->depth--;
28914         }
28915         ndr->depth--;
28916 }
28917
28918 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
28919 {
28920         if (flags & NDR_IN) {
28921         }
28922         if (flags & NDR_OUT) {
28923                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28924         }
28925         return NDR_ERR_SUCCESS;
28926 }
28927
28928 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
28929 {
28930         if (flags & NDR_IN) {
28931         }
28932         if (flags & NDR_OUT) {
28933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28934         }
28935         return NDR_ERR_SUCCESS;
28936 }
28937
28938 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
28939 {
28940         ndr_print_struct(ndr, name, "spoolss_56");
28941         ndr->depth++;
28942         if (flags & NDR_SET_VALUES) {
28943                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28944         }
28945         if (flags & NDR_IN) {
28946                 ndr_print_struct(ndr, "in", "spoolss_56");
28947                 ndr->depth++;
28948                 ndr->depth--;
28949         }
28950         if (flags & NDR_OUT) {
28951                 ndr_print_struct(ndr, "out", "spoolss_56");
28952                 ndr->depth++;
28953                 ndr_print_WERROR(ndr, "result", r->out.result);
28954                 ndr->depth--;
28955         }
28956         ndr->depth--;
28957 }
28958
28959 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
28960 {
28961         if (flags & NDR_IN) {
28962         }
28963         if (flags & NDR_OUT) {
28964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
28965         }
28966         return NDR_ERR_SUCCESS;
28967 }
28968
28969 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
28970 {
28971         if (flags & NDR_IN) {
28972         }
28973         if (flags & NDR_OUT) {
28974                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
28975         }
28976         return NDR_ERR_SUCCESS;
28977 }
28978
28979 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
28980 {
28981         ndr_print_struct(ndr, name, "spoolss_57");
28982         ndr->depth++;
28983         if (flags & NDR_SET_VALUES) {
28984                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
28985         }
28986         if (flags & NDR_IN) {
28987                 ndr_print_struct(ndr, "in", "spoolss_57");
28988                 ndr->depth++;
28989                 ndr->depth--;
28990         }
28991         if (flags & NDR_OUT) {
28992                 ndr_print_struct(ndr, "out", "spoolss_57");
28993                 ndr->depth++;
28994                 ndr_print_WERROR(ndr, "result", r->out.result);
28995                 ndr->depth--;
28996         }
28997         ndr->depth--;
28998 }
28999
29000 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
29001 {
29002         if (flags & NDR_IN) {
29003                 if (r->in.handle == NULL) {
29004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29005                 }
29006                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29007                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29008                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29009                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
29010                 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));
29011                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
29012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
29013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
29014                 if (r->in.status_code == NULL) {
29015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29016                 }
29017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
29018         }
29019         if (flags & NDR_OUT) {
29020                 if (r->out.out_data == NULL) {
29021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29022                 }
29023                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.out_data_size));
29024                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
29025                 if (r->out.needed == NULL) {
29026                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29027                 }
29028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
29029                 if (r->out.status_code == NULL) {
29030                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29031                 }
29032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
29033                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29034         }
29035         return NDR_ERR_SUCCESS;
29036 }
29037
29038 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
29039 {
29040         TALLOC_CTX *_mem_save_handle_0;
29041         TALLOC_CTX *_mem_save_needed_0;
29042         TALLOC_CTX *_mem_save_status_code_0;
29043         if (flags & NDR_IN) {
29044                 ZERO_STRUCT(r->out);
29045
29046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29047                         NDR_PULL_ALLOC(ndr, r->in.handle);
29048                 }
29049                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
29050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
29051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
29052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
29053                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
29054                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
29055                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
29056                         return 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));
29057                 }
29058                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
29059                 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));
29060                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
29061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
29062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
29063                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29064                         NDR_PULL_ALLOC(ndr, r->in.status_code);
29065                 }
29066                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29067                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
29068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
29069                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29070                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
29071                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
29072                 NDR_PULL_ALLOC(ndr, r->out.needed);
29073                 ZERO_STRUCTP(r->out.needed);
29074                 NDR_PULL_ALLOC(ndr, r->out.status_code);
29075                 *r->out.status_code = *r->in.status_code;
29076         }
29077         if (flags & NDR_OUT) {
29078                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
29079                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29080                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
29081                 }
29082                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
29083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29084                         NDR_PULL_ALLOC(ndr, r->out.needed);
29085                 }
29086                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
29087                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
29088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
29089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
29090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29091                         NDR_PULL_ALLOC(ndr, r->out.status_code);
29092                 }
29093                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
29094                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
29095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
29096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
29097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29098                 if (r->out.out_data) {
29099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
29100                 }
29101         }
29102         return NDR_ERR_SUCCESS;
29103 }
29104
29105 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
29106 {
29107         ndr_print_struct(ndr, name, "spoolss_XcvData");
29108         ndr->depth++;
29109         if (flags & NDR_SET_VALUES) {
29110                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29111         }
29112         if (flags & NDR_IN) {
29113                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
29114                 ndr->depth++;
29115                 ndr_print_ptr(ndr, "handle", r->in.handle);
29116                 ndr->depth++;
29117                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
29118                 ndr->depth--;
29119                 ndr_print_string(ndr, "function_name", r->in.function_name);
29120                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
29121                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
29122                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
29123                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
29124                 ndr->depth++;
29125                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
29126                 ndr->depth--;
29127                 ndr->depth--;
29128         }
29129         if (flags & NDR_OUT) {
29130                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
29131                 ndr->depth++;
29132                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
29133                 ndr->depth++;
29134                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
29135                 ndr->depth--;
29136                 ndr_print_ptr(ndr, "needed", r->out.needed);
29137                 ndr->depth++;
29138                 ndr_print_uint32(ndr, "needed", *r->out.needed);
29139                 ndr->depth--;
29140                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
29141                 ndr->depth++;
29142                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
29143                 ndr->depth--;
29144                 ndr_print_WERROR(ndr, "result", r->out.result);
29145                 ndr->depth--;
29146         }
29147         ndr->depth--;
29148 }
29149
29150 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
29151 {
29152         if (flags & NDR_IN) {
29153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29154                 if (r->in.servername) {
29155                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29156                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29157                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29158                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29159                 }
29160                 if (r->in.info_ctr == NULL) {
29161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29162                 }
29163                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29164                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
29165         }
29166         if (flags & NDR_OUT) {
29167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29168         }
29169         return NDR_ERR_SUCCESS;
29170 }
29171
29172 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
29173 {
29174         uint32_t _ptr_servername;
29175         TALLOC_CTX *_mem_save_servername_0;
29176         TALLOC_CTX *_mem_save_info_ctr_0;
29177         if (flags & NDR_IN) {
29178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29179                 if (_ptr_servername) {
29180                         NDR_PULL_ALLOC(ndr, r->in.servername);
29181                 } else {
29182                         r->in.servername = NULL;
29183                 }
29184                 if (r->in.servername) {
29185                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29186                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29189                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29190                                 return 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));
29191                         }
29192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29195                 }
29196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29197                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
29198                 }
29199                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
29200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
29201                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
29202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
29203                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
29204         }
29205         if (flags & NDR_OUT) {
29206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29207         }
29208         return NDR_ERR_SUCCESS;
29209 }
29210
29211 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
29212 {
29213         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
29214         ndr->depth++;
29215         if (flags & NDR_SET_VALUES) {
29216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29217         }
29218         if (flags & NDR_IN) {
29219                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
29220                 ndr->depth++;
29221                 ndr_print_ptr(ndr, "servername", r->in.servername);
29222                 ndr->depth++;
29223                 if (r->in.servername) {
29224                         ndr_print_string(ndr, "servername", r->in.servername);
29225                 }
29226                 ndr->depth--;
29227                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
29228                 ndr->depth++;
29229                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
29230                 ndr->depth--;
29231                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
29232                 ndr->depth--;
29233         }
29234         if (flags & NDR_OUT) {
29235                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
29236                 ndr->depth++;
29237                 ndr_print_WERROR(ndr, "result", r->out.result);
29238                 ndr->depth--;
29239         }
29240         ndr->depth--;
29241 }
29242
29243 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
29244 {
29245         if (flags & NDR_IN) {
29246         }
29247         if (flags & NDR_OUT) {
29248                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29249         }
29250         return NDR_ERR_SUCCESS;
29251 }
29252
29253 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
29254 {
29255         if (flags & NDR_IN) {
29256         }
29257         if (flags & NDR_OUT) {
29258                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29259         }
29260         return NDR_ERR_SUCCESS;
29261 }
29262
29263 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
29264 {
29265         ndr_print_struct(ndr, name, "spoolss_5a");
29266         ndr->depth++;
29267         if (flags & NDR_SET_VALUES) {
29268                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29269         }
29270         if (flags & NDR_IN) {
29271                 ndr_print_struct(ndr, "in", "spoolss_5a");
29272                 ndr->depth++;
29273                 ndr->depth--;
29274         }
29275         if (flags & NDR_OUT) {
29276                 ndr_print_struct(ndr, "out", "spoolss_5a");
29277                 ndr->depth++;
29278                 ndr_print_WERROR(ndr, "result", r->out.result);
29279                 ndr->depth--;
29280         }
29281         ndr->depth--;
29282 }
29283
29284 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
29285 {
29286         if (flags & NDR_IN) {
29287         }
29288         if (flags & NDR_OUT) {
29289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29290         }
29291         return NDR_ERR_SUCCESS;
29292 }
29293
29294 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
29295 {
29296         if (flags & NDR_IN) {
29297         }
29298         if (flags & NDR_OUT) {
29299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29300         }
29301         return NDR_ERR_SUCCESS;
29302 }
29303
29304 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
29305 {
29306         ndr_print_struct(ndr, name, "spoolss_5b");
29307         ndr->depth++;
29308         if (flags & NDR_SET_VALUES) {
29309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29310         }
29311         if (flags & NDR_IN) {
29312                 ndr_print_struct(ndr, "in", "spoolss_5b");
29313                 ndr->depth++;
29314                 ndr->depth--;
29315         }
29316         if (flags & NDR_OUT) {
29317                 ndr_print_struct(ndr, "out", "spoolss_5b");
29318                 ndr->depth++;
29319                 ndr_print_WERROR(ndr, "result", r->out.result);
29320                 ndr->depth--;
29321         }
29322         ndr->depth--;
29323 }
29324
29325 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
29326 {
29327         if (flags & NDR_IN) {
29328         }
29329         if (flags & NDR_OUT) {
29330                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29331         }
29332         return NDR_ERR_SUCCESS;
29333 }
29334
29335 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
29336 {
29337         if (flags & NDR_IN) {
29338         }
29339         if (flags & NDR_OUT) {
29340                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29341         }
29342         return NDR_ERR_SUCCESS;
29343 }
29344
29345 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
29346 {
29347         ndr_print_struct(ndr, name, "spoolss_5c");
29348         ndr->depth++;
29349         if (flags & NDR_SET_VALUES) {
29350                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29351         }
29352         if (flags & NDR_IN) {
29353                 ndr_print_struct(ndr, "in", "spoolss_5c");
29354                 ndr->depth++;
29355                 ndr->depth--;
29356         }
29357         if (flags & NDR_OUT) {
29358                 ndr_print_struct(ndr, "out", "spoolss_5c");
29359                 ndr->depth++;
29360                 ndr_print_WERROR(ndr, "result", r->out.result);
29361                 ndr->depth--;
29362         }
29363         ndr->depth--;
29364 }
29365
29366 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
29367 {
29368         if (flags & NDR_IN) {
29369         }
29370         if (flags & NDR_OUT) {
29371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29372         }
29373         return NDR_ERR_SUCCESS;
29374 }
29375
29376 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
29377 {
29378         if (flags & NDR_IN) {
29379         }
29380         if (flags & NDR_OUT) {
29381                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29382         }
29383         return NDR_ERR_SUCCESS;
29384 }
29385
29386 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
29387 {
29388         ndr_print_struct(ndr, name, "spoolss_5d");
29389         ndr->depth++;
29390         if (flags & NDR_SET_VALUES) {
29391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29392         }
29393         if (flags & NDR_IN) {
29394                 ndr_print_struct(ndr, "in", "spoolss_5d");
29395                 ndr->depth++;
29396                 ndr->depth--;
29397         }
29398         if (flags & NDR_OUT) {
29399                 ndr_print_struct(ndr, "out", "spoolss_5d");
29400                 ndr->depth++;
29401                 ndr_print_WERROR(ndr, "result", r->out.result);
29402                 ndr->depth--;
29403         }
29404         ndr->depth--;
29405 }
29406
29407 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
29408 {
29409         if (flags & NDR_IN) {
29410         }
29411         if (flags & NDR_OUT) {
29412                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29413         }
29414         return NDR_ERR_SUCCESS;
29415 }
29416
29417 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
29418 {
29419         if (flags & NDR_IN) {
29420         }
29421         if (flags & NDR_OUT) {
29422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29423         }
29424         return NDR_ERR_SUCCESS;
29425 }
29426
29427 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
29428 {
29429         ndr_print_struct(ndr, name, "spoolss_5e");
29430         ndr->depth++;
29431         if (flags & NDR_SET_VALUES) {
29432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29433         }
29434         if (flags & NDR_IN) {
29435                 ndr_print_struct(ndr, "in", "spoolss_5e");
29436                 ndr->depth++;
29437                 ndr->depth--;
29438         }
29439         if (flags & NDR_OUT) {
29440                 ndr_print_struct(ndr, "out", "spoolss_5e");
29441                 ndr->depth++;
29442                 ndr_print_WERROR(ndr, "result", r->out.result);
29443                 ndr->depth--;
29444         }
29445         ndr->depth--;
29446 }
29447
29448 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
29449 {
29450         if (flags & NDR_IN) {
29451         }
29452         if (flags & NDR_OUT) {
29453                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29454         }
29455         return NDR_ERR_SUCCESS;
29456 }
29457
29458 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
29459 {
29460         if (flags & NDR_IN) {
29461         }
29462         if (flags & NDR_OUT) {
29463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29464         }
29465         return NDR_ERR_SUCCESS;
29466 }
29467
29468 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
29469 {
29470         ndr_print_struct(ndr, name, "spoolss_5f");
29471         ndr->depth++;
29472         if (flags & NDR_SET_VALUES) {
29473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29474         }
29475         if (flags & NDR_IN) {
29476                 ndr_print_struct(ndr, "in", "spoolss_5f");
29477                 ndr->depth++;
29478                 ndr->depth--;
29479         }
29480         if (flags & NDR_OUT) {
29481                 ndr_print_struct(ndr, "out", "spoolss_5f");
29482                 ndr->depth++;
29483                 ndr_print_WERROR(ndr, "result", r->out.result);
29484                 ndr->depth--;
29485         }
29486         ndr->depth--;
29487 }
29488
29489 static enum ndr_err_code ndr_push_spoolss_60(struct ndr_push *ndr, int flags, const struct spoolss_60 *r)
29490 {
29491         if (flags & NDR_IN) {
29492         }
29493         if (flags & NDR_OUT) {
29494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29495         }
29496         return NDR_ERR_SUCCESS;
29497 }
29498
29499 static enum ndr_err_code ndr_pull_spoolss_60(struct ndr_pull *ndr, int flags, struct spoolss_60 *r)
29500 {
29501         if (flags & NDR_IN) {
29502         }
29503         if (flags & NDR_OUT) {
29504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29505         }
29506         return NDR_ERR_SUCCESS;
29507 }
29508
29509 _PUBLIC_ void ndr_print_spoolss_60(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_60 *r)
29510 {
29511         ndr_print_struct(ndr, name, "spoolss_60");
29512         ndr->depth++;
29513         if (flags & NDR_SET_VALUES) {
29514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29515         }
29516         if (flags & NDR_IN) {
29517                 ndr_print_struct(ndr, "in", "spoolss_60");
29518                 ndr->depth++;
29519                 ndr->depth--;
29520         }
29521         if (flags & NDR_OUT) {
29522                 ndr_print_struct(ndr, "out", "spoolss_60");
29523                 ndr->depth++;
29524                 ndr_print_WERROR(ndr, "result", r->out.result);
29525                 ndr->depth--;
29526         }
29527         ndr->depth--;
29528 }
29529
29530 static enum ndr_err_code ndr_push_spoolss_61(struct ndr_push *ndr, int flags, const struct spoolss_61 *r)
29531 {
29532         if (flags & NDR_IN) {
29533         }
29534         if (flags & NDR_OUT) {
29535                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29536         }
29537         return NDR_ERR_SUCCESS;
29538 }
29539
29540 static enum ndr_err_code ndr_pull_spoolss_61(struct ndr_pull *ndr, int flags, struct spoolss_61 *r)
29541 {
29542         if (flags & NDR_IN) {
29543         }
29544         if (flags & NDR_OUT) {
29545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29546         }
29547         return NDR_ERR_SUCCESS;
29548 }
29549
29550 _PUBLIC_ void ndr_print_spoolss_61(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_61 *r)
29551 {
29552         ndr_print_struct(ndr, name, "spoolss_61");
29553         ndr->depth++;
29554         if (flags & NDR_SET_VALUES) {
29555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29556         }
29557         if (flags & NDR_IN) {
29558                 ndr_print_struct(ndr, "in", "spoolss_61");
29559                 ndr->depth++;
29560                 ndr->depth--;
29561         }
29562         if (flags & NDR_OUT) {
29563                 ndr_print_struct(ndr, "out", "spoolss_61");
29564                 ndr->depth++;
29565                 ndr_print_WERROR(ndr, "result", r->out.result);
29566                 ndr->depth--;
29567         }
29568         ndr->depth--;
29569 }
29570
29571 static enum ndr_err_code ndr_push_spoolss_62(struct ndr_push *ndr, int flags, const struct spoolss_62 *r)
29572 {
29573         if (flags & NDR_IN) {
29574         }
29575         if (flags & NDR_OUT) {
29576                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29577         }
29578         return NDR_ERR_SUCCESS;
29579 }
29580
29581 static enum ndr_err_code ndr_pull_spoolss_62(struct ndr_pull *ndr, int flags, struct spoolss_62 *r)
29582 {
29583         if (flags & NDR_IN) {
29584         }
29585         if (flags & NDR_OUT) {
29586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29587         }
29588         return NDR_ERR_SUCCESS;
29589 }
29590
29591 _PUBLIC_ void ndr_print_spoolss_62(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_62 *r)
29592 {
29593         ndr_print_struct(ndr, name, "spoolss_62");
29594         ndr->depth++;
29595         if (flags & NDR_SET_VALUES) {
29596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29597         }
29598         if (flags & NDR_IN) {
29599                 ndr_print_struct(ndr, "in", "spoolss_62");
29600                 ndr->depth++;
29601                 ndr->depth--;
29602         }
29603         if (flags & NDR_OUT) {
29604                 ndr_print_struct(ndr, "out", "spoolss_62");
29605                 ndr->depth++;
29606                 ndr_print_WERROR(ndr, "result", r->out.result);
29607                 ndr->depth--;
29608         }
29609         ndr->depth--;
29610 }
29611
29612 static enum ndr_err_code ndr_push_spoolss_63(struct ndr_push *ndr, int flags, const struct spoolss_63 *r)
29613 {
29614         if (flags & NDR_IN) {
29615         }
29616         if (flags & NDR_OUT) {
29617                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29618         }
29619         return NDR_ERR_SUCCESS;
29620 }
29621
29622 static enum ndr_err_code ndr_pull_spoolss_63(struct ndr_pull *ndr, int flags, struct spoolss_63 *r)
29623 {
29624         if (flags & NDR_IN) {
29625         }
29626         if (flags & NDR_OUT) {
29627                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29628         }
29629         return NDR_ERR_SUCCESS;
29630 }
29631
29632 _PUBLIC_ void ndr_print_spoolss_63(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_63 *r)
29633 {
29634         ndr_print_struct(ndr, name, "spoolss_63");
29635         ndr->depth++;
29636         if (flags & NDR_SET_VALUES) {
29637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29638         }
29639         if (flags & NDR_IN) {
29640                 ndr_print_struct(ndr, "in", "spoolss_63");
29641                 ndr->depth++;
29642                 ndr->depth--;
29643         }
29644         if (flags & NDR_OUT) {
29645                 ndr_print_struct(ndr, "out", "spoolss_63");
29646                 ndr->depth++;
29647                 ndr_print_WERROR(ndr, "result", r->out.result);
29648                 ndr->depth--;
29649         }
29650         ndr->depth--;
29651 }
29652
29653 static enum ndr_err_code ndr_push_spoolss_64(struct ndr_push *ndr, int flags, const struct spoolss_64 *r)
29654 {
29655         if (flags & NDR_IN) {
29656         }
29657         if (flags & NDR_OUT) {
29658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29659         }
29660         return NDR_ERR_SUCCESS;
29661 }
29662
29663 static enum ndr_err_code ndr_pull_spoolss_64(struct ndr_pull *ndr, int flags, struct spoolss_64 *r)
29664 {
29665         if (flags & NDR_IN) {
29666         }
29667         if (flags & NDR_OUT) {
29668                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29669         }
29670         return NDR_ERR_SUCCESS;
29671 }
29672
29673 _PUBLIC_ void ndr_print_spoolss_64(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_64 *r)
29674 {
29675         ndr_print_struct(ndr, name, "spoolss_64");
29676         ndr->depth++;
29677         if (flags & NDR_SET_VALUES) {
29678                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29679         }
29680         if (flags & NDR_IN) {
29681                 ndr_print_struct(ndr, "in", "spoolss_64");
29682                 ndr->depth++;
29683                 ndr->depth--;
29684         }
29685         if (flags & NDR_OUT) {
29686                 ndr_print_struct(ndr, "out", "spoolss_64");
29687                 ndr->depth++;
29688                 ndr_print_WERROR(ndr, "result", r->out.result);
29689                 ndr->depth--;
29690         }
29691         ndr->depth--;
29692 }
29693
29694 static enum ndr_err_code ndr_push_spoolss_65(struct ndr_push *ndr, int flags, const struct spoolss_65 *r)
29695 {
29696         if (flags & NDR_IN) {
29697         }
29698         if (flags & NDR_OUT) {
29699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29700         }
29701         return NDR_ERR_SUCCESS;
29702 }
29703
29704 static enum ndr_err_code ndr_pull_spoolss_65(struct ndr_pull *ndr, int flags, struct spoolss_65 *r)
29705 {
29706         if (flags & NDR_IN) {
29707         }
29708         if (flags & NDR_OUT) {
29709                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29710         }
29711         return NDR_ERR_SUCCESS;
29712 }
29713
29714 _PUBLIC_ void ndr_print_spoolss_65(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_65 *r)
29715 {
29716         ndr_print_struct(ndr, name, "spoolss_65");
29717         ndr->depth++;
29718         if (flags & NDR_SET_VALUES) {
29719                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29720         }
29721         if (flags & NDR_IN) {
29722                 ndr_print_struct(ndr, "in", "spoolss_65");
29723                 ndr->depth++;
29724                 ndr->depth--;
29725         }
29726         if (flags & NDR_OUT) {
29727                 ndr_print_struct(ndr, "out", "spoolss_65");
29728                 ndr->depth++;
29729                 ndr_print_WERROR(ndr, "result", r->out.result);
29730                 ndr->depth--;
29731         }
29732         ndr->depth--;
29733 }
29734
29735 static enum ndr_err_code ndr_push_spoolss_GetCorePrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29736 {
29737         uint32_t cntr_core_printer_drivers_1;
29738         if (flags & NDR_IN) {
29739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29740                 if (r->in.servername) {
29741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29743                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29745                 }
29746                 if (r->in.architecture == NULL) {
29747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29748                 }
29749                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29750                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29751                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29752                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_driver_size));
29754                 if (r->in.core_driver_dependencies == NULL) {
29755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29756                 }
29757                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_driver_size));
29758                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.core_driver_dependencies, r->in.core_driver_size, sizeof(uint16_t), CH_UTF16));
29759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29760         }
29761         if (flags & NDR_OUT) {
29762                 if (r->out.core_printer_drivers == NULL) {
29763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29764                 }
29765                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.core_printer_driver_count));
29766                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29767                         NDR_CHECK(ndr_push_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29768                 }
29769                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29770         }
29771         return NDR_ERR_SUCCESS;
29772 }
29773
29774 static enum ndr_err_code ndr_pull_spoolss_GetCorePrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_GetCorePrinterDrivers *r)
29775 {
29776         uint32_t _ptr_servername;
29777         uint32_t cntr_core_printer_drivers_1;
29778         TALLOC_CTX *_mem_save_servername_0;
29779         TALLOC_CTX *_mem_save_core_printer_drivers_1;
29780         if (flags & NDR_IN) {
29781                 ZERO_STRUCT(r->out);
29782
29783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29784                 if (_ptr_servername) {
29785                         NDR_PULL_ALLOC(ndr, r->in.servername);
29786                 } else {
29787                         r->in.servername = NULL;
29788                 }
29789                 if (r->in.servername) {
29790                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
29791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
29792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
29793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
29794                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
29795                                 return 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));
29796                         }
29797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
29798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
29799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
29800                 }
29801                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
29802                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
29803                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
29804                         return 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));
29805                 }
29806                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
29807                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
29808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_driver_size));
29809                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.core_driver_dependencies));
29810                 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));
29811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.core_printer_driver_count));
29812                 NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, r->in.core_printer_driver_count);
29813                 memset(r->out.core_printer_drivers, 0, (r->in.core_printer_driver_count) * sizeof(*r->out.core_printer_drivers));
29814                 if (r->in.core_driver_dependencies) {
29815                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.core_driver_dependencies, r->in.core_driver_size));
29816                 }
29817         }
29818         if (flags & NDR_OUT) {
29819                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.core_printer_drivers));
29820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
29821                         NDR_PULL_ALLOC_N(ndr, r->out.core_printer_drivers, ndr_get_array_size(ndr, &r->out.core_printer_drivers));
29822                 }
29823                 _mem_save_core_printer_drivers_1 = NDR_PULL_GET_MEM_CTX(ndr);
29824                 NDR_PULL_SET_MEM_CTX(ndr, r->out.core_printer_drivers, 0);
29825                 for (cntr_core_printer_drivers_1 = 0; cntr_core_printer_drivers_1 < r->in.core_printer_driver_count; cntr_core_printer_drivers_1++) {
29826                         NDR_CHECK(ndr_pull_spoolss_CorePrinterDriver(ndr, NDR_SCALARS, &r->out.core_printer_drivers[cntr_core_printer_drivers_1]));
29827                 }
29828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_printer_drivers_1, 0);
29829                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29830                 if (r->out.core_printer_drivers) {
29831                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.core_printer_drivers, r->in.core_printer_driver_count));
29832                 }
29833         }
29834         return NDR_ERR_SUCCESS;
29835 }
29836
29837 _PUBLIC_ void ndr_print_spoolss_GetCorePrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetCorePrinterDrivers *r)
29838 {
29839         uint32_t cntr_core_printer_drivers_1;
29840         ndr_print_struct(ndr, name, "spoolss_GetCorePrinterDrivers");
29841         ndr->depth++;
29842         if (flags & NDR_SET_VALUES) {
29843                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29844         }
29845         if (flags & NDR_IN) {
29846                 ndr_print_struct(ndr, "in", "spoolss_GetCorePrinterDrivers");
29847                 ndr->depth++;
29848                 ndr_print_ptr(ndr, "servername", r->in.servername);
29849                 ndr->depth++;
29850                 if (r->in.servername) {
29851                         ndr_print_string(ndr, "servername", r->in.servername);
29852                 }
29853                 ndr->depth--;
29854                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
29855                 ndr->depth++;
29856                 ndr_print_string(ndr, "architecture", r->in.architecture);
29857                 ndr->depth--;
29858                 ndr_print_uint32(ndr, "core_driver_size", r->in.core_driver_size);
29859                 ndr_print_ptr(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29860                 ndr->depth++;
29861                 ndr_print_string(ndr, "core_driver_dependencies", r->in.core_driver_dependencies);
29862                 ndr->depth--;
29863                 ndr_print_uint32(ndr, "core_printer_driver_count", r->in.core_printer_driver_count);
29864                 ndr->depth--;
29865         }
29866         if (flags & NDR_OUT) {
29867                 ndr_print_struct(ndr, "out", "spoolss_GetCorePrinterDrivers");
29868                 ndr->depth++;
29869                 ndr_print_ptr(ndr, "core_printer_drivers", r->out.core_printer_drivers);
29870                 ndr->depth++;
29871                 ndr->print(ndr, "%s: ARRAY(%d)", "core_printer_drivers", (int)r->in.core_printer_driver_count);
29872                 ndr->depth++;
29873                 for (cntr_core_printer_drivers_1=0;cntr_core_printer_drivers_1<r->in.core_printer_driver_count;cntr_core_printer_drivers_1++) {
29874                         char *idx_1=NULL;
29875                         if (asprintf(&idx_1, "[%d]", cntr_core_printer_drivers_1) != -1) {
29876                                 ndr_print_spoolss_CorePrinterDriver(ndr, "core_printer_drivers", &r->out.core_printer_drivers[cntr_core_printer_drivers_1]);
29877                                 free(idx_1);
29878                         }
29879                 }
29880                 ndr->depth--;
29881                 ndr->depth--;
29882                 ndr_print_WERROR(ndr, "result", r->out.result);
29883                 ndr->depth--;
29884         }
29885         ndr->depth--;
29886 }
29887
29888 static enum ndr_err_code ndr_push_spoolss_67(struct ndr_push *ndr, int flags, const struct spoolss_67 *r)
29889 {
29890         if (flags & NDR_IN) {
29891         }
29892         if (flags & NDR_OUT) {
29893                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29894         }
29895         return NDR_ERR_SUCCESS;
29896 }
29897
29898 static enum ndr_err_code ndr_pull_spoolss_67(struct ndr_pull *ndr, int flags, struct spoolss_67 *r)
29899 {
29900         if (flags & NDR_IN) {
29901         }
29902         if (flags & NDR_OUT) {
29903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
29904         }
29905         return NDR_ERR_SUCCESS;
29906 }
29907
29908 _PUBLIC_ void ndr_print_spoolss_67(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_67 *r)
29909 {
29910         ndr_print_struct(ndr, name, "spoolss_67");
29911         ndr->depth++;
29912         if (flags & NDR_SET_VALUES) {
29913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
29914         }
29915         if (flags & NDR_IN) {
29916                 ndr_print_struct(ndr, "in", "spoolss_67");
29917                 ndr->depth++;
29918                 ndr->depth--;
29919         }
29920         if (flags & NDR_OUT) {
29921                 ndr_print_struct(ndr, "out", "spoolss_67");
29922                 ndr->depth++;
29923                 ndr_print_WERROR(ndr, "result", r->out.result);
29924                 ndr->depth--;
29925         }
29926         ndr->depth--;
29927 }
29928
29929 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriverPackagePath(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
29930 {
29931         if (flags & NDR_IN) {
29932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
29933                 if (r->in.servername) {
29934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29936                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
29937                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29938                 }
29939                 if (r->in.architecture == NULL) {
29940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29941                 }
29942                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29943                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29944                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
29945                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.language));
29947                 if (r->in.language) {
29948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.language, CH_UTF16)));
29951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.language, ndr_charset_length(r->in.language, CH_UTF16), sizeof(uint16_t), CH_UTF16));
29952                 }
29953                 if (r->in.package_id == NULL) {
29954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29955                 }
29956                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29957                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
29958                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->in.package_id, CH_UTF16)));
29959                 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));
29960                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.driver_package_cab));
29961                 if (r->in.driver_package_cab) {
29962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29964                 }
29965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29966         }
29967         if (flags & NDR_OUT) {
29968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.driver_package_cab));
29969                 if (r->out.driver_package_cab) {
29970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->in.driver_package_cab_size));
29971                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.driver_package_cab, r->in.driver_package_cab_size, sizeof(uint16_t), CH_UTF16));
29972                 }
29973                 if (r->out.required == NULL) {
29974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
29975                 }
29976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.required));
29977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
29978         }
29979         return NDR_ERR_SUCCESS;
29980 }
29981
29982 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverPackagePath(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverPackagePath *r)
29983 {
29984         uint32_t _ptr_servername;
29985         uint32_t _ptr_language;
29986         uint32_t _ptr_driver_package_cab;
29987         TALLOC_CTX *_mem_save_servername_0;
29988         TALLOC_CTX *_mem_save_language_0;
29989         TALLOC_CTX *_mem_save_driver_package_cab_0;
29990         TALLOC_CTX *_mem_save_required_0;
29991         if (flags & NDR_IN) {
29992                 ZERO_STRUCT(r->out);
29993
29994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
29995                 if (_ptr_servername) {
29996                         NDR_PULL_ALLOC(ndr, r->in.servername);
29997                 } else {
29998                         r->in.servername = NULL;
29999                 }
30000                 if (r->in.servername) {
30001                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
30002                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
30003                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
30004                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
30005                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
30006                                 return 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));
30007                         }
30008                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
30009                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
30010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
30011                 }
30012                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
30013                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
30014                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
30015                         return 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));
30016                 }
30017                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
30018                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
30019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_language));
30020                 if (_ptr_language) {
30021                         NDR_PULL_ALLOC(ndr, r->in.language);
30022                 } else {
30023                         r->in.language = NULL;
30024                 }
30025                 if (r->in.language) {
30026                         _mem_save_language_0 = NDR_PULL_GET_MEM_CTX(ndr);
30027                         NDR_PULL_SET_MEM_CTX(ndr, r->in.language, 0);
30028                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.language));
30029                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.language));
30030                         if (ndr_get_array_length(ndr, &r->in.language) > ndr_get_array_size(ndr, &r->in.language)) {
30031                                 return 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));
30032                         }
30033                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t)));
30034                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.language, ndr_get_array_length(ndr, &r->in.language), sizeof(uint16_t), CH_UTF16));
30035                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_language_0, 0);
30036                 }
30037                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.package_id));
30038                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.package_id));
30039                 if (ndr_get_array_length(ndr, &r->in.package_id) > ndr_get_array_size(ndr, &r->in.package_id)) {
30040                         return 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));
30041                 }
30042                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.package_id), sizeof(uint16_t)));
30043                 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));
30044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30045                 if (_ptr_driver_package_cab) {
30046                         NDR_PULL_ALLOC(ndr, r->in.driver_package_cab);
30047                 } else {
30048                         r->in.driver_package_cab = NULL;
30049                 }
30050                 if (r->in.driver_package_cab) {
30051                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30052                         NDR_PULL_SET_MEM_CTX(ndr, r->in.driver_package_cab, 0);
30053                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver_package_cab));
30054                         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));
30055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30056                 }
30057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.driver_package_cab_size));
30058                 NDR_PULL_ALLOC(ndr, r->out.required);
30059                 ZERO_STRUCTP(r->out.required);
30060                 if (r->in.driver_package_cab) {
30061                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.driver_package_cab, r->in.driver_package_cab_size));
30062                 }
30063         }
30064         if (flags & NDR_OUT) {
30065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_package_cab));
30066                 if (_ptr_driver_package_cab) {
30067                         NDR_PULL_ALLOC(ndr, r->out.driver_package_cab);
30068                 } else {
30069                         r->out.driver_package_cab = NULL;
30070                 }
30071                 if (r->out.driver_package_cab) {
30072                         _mem_save_driver_package_cab_0 = NDR_PULL_GET_MEM_CTX(ndr);
30073                         NDR_PULL_SET_MEM_CTX(ndr, r->out.driver_package_cab, 0);
30074                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.driver_package_cab));
30075                         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));
30076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_package_cab_0, 0);
30077                 }
30078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
30079                         NDR_PULL_ALLOC(ndr, r->out.required);
30080                 }
30081                 _mem_save_required_0 = NDR_PULL_GET_MEM_CTX(ndr);
30082                 NDR_PULL_SET_MEM_CTX(ndr, r->out.required, LIBNDR_FLAG_REF_ALLOC);
30083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.required));
30084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_required_0, LIBNDR_FLAG_REF_ALLOC);
30085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30086                 if (r->out.driver_package_cab) {
30087                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.driver_package_cab, r->in.driver_package_cab_size));
30088                 }
30089         }
30090         return NDR_ERR_SUCCESS;
30091 }
30092
30093 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverPackagePath(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverPackagePath *r)
30094 {
30095         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverPackagePath");
30096         ndr->depth++;
30097         if (flags & NDR_SET_VALUES) {
30098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30099         }
30100         if (flags & NDR_IN) {
30101                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverPackagePath");
30102                 ndr->depth++;
30103                 ndr_print_ptr(ndr, "servername", r->in.servername);
30104                 ndr->depth++;
30105                 if (r->in.servername) {
30106                         ndr_print_string(ndr, "servername", r->in.servername);
30107                 }
30108                 ndr->depth--;
30109                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
30110                 ndr->depth++;
30111                 ndr_print_string(ndr, "architecture", r->in.architecture);
30112                 ndr->depth--;
30113                 ndr_print_ptr(ndr, "language", r->in.language);
30114                 ndr->depth++;
30115                 if (r->in.language) {
30116                         ndr_print_string(ndr, "language", r->in.language);
30117                 }
30118                 ndr->depth--;
30119                 ndr_print_ptr(ndr, "package_id", r->in.package_id);
30120                 ndr->depth++;
30121                 ndr_print_string(ndr, "package_id", r->in.package_id);
30122                 ndr->depth--;
30123                 ndr_print_ptr(ndr, "driver_package_cab", r->in.driver_package_cab);
30124                 ndr->depth++;
30125                 if (r->in.driver_package_cab) {
30126                         ndr_print_string(ndr, "driver_package_cab", r->in.driver_package_cab);
30127                 }
30128                 ndr->depth--;
30129                 ndr_print_uint32(ndr, "driver_package_cab_size", r->in.driver_package_cab_size);
30130                 ndr->depth--;
30131         }
30132         if (flags & NDR_OUT) {
30133                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverPackagePath");
30134                 ndr->depth++;
30135                 ndr_print_ptr(ndr, "driver_package_cab", r->out.driver_package_cab);
30136                 ndr->depth++;
30137                 if (r->out.driver_package_cab) {
30138                         ndr_print_string(ndr, "driver_package_cab", r->out.driver_package_cab);
30139                 }
30140                 ndr->depth--;
30141                 ndr_print_ptr(ndr, "required", r->out.required);
30142                 ndr->depth++;
30143                 ndr_print_uint32(ndr, "required", *r->out.required);
30144                 ndr->depth--;
30145                 ndr_print_WERROR(ndr, "result", r->out.result);
30146                 ndr->depth--;
30147         }
30148         ndr->depth--;
30149 }
30150
30151 static enum ndr_err_code ndr_push_spoolss_69(struct ndr_push *ndr, int flags, const struct spoolss_69 *r)
30152 {
30153         if (flags & NDR_IN) {
30154         }
30155         if (flags & NDR_OUT) {
30156                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30157         }
30158         return NDR_ERR_SUCCESS;
30159 }
30160
30161 static enum ndr_err_code ndr_pull_spoolss_69(struct ndr_pull *ndr, int flags, struct spoolss_69 *r)
30162 {
30163         if (flags & NDR_IN) {
30164         }
30165         if (flags & NDR_OUT) {
30166                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30167         }
30168         return NDR_ERR_SUCCESS;
30169 }
30170
30171 _PUBLIC_ void ndr_print_spoolss_69(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_69 *r)
30172 {
30173         ndr_print_struct(ndr, name, "spoolss_69");
30174         ndr->depth++;
30175         if (flags & NDR_SET_VALUES) {
30176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30177         }
30178         if (flags & NDR_IN) {
30179                 ndr_print_struct(ndr, "in", "spoolss_69");
30180                 ndr->depth++;
30181                 ndr->depth--;
30182         }
30183         if (flags & NDR_OUT) {
30184                 ndr_print_struct(ndr, "out", "spoolss_69");
30185                 ndr->depth++;
30186                 ndr_print_WERROR(ndr, "result", r->out.result);
30187                 ndr->depth--;
30188         }
30189         ndr->depth--;
30190 }
30191
30192 static enum ndr_err_code ndr_push_spoolss_6a(struct ndr_push *ndr, int flags, const struct spoolss_6a *r)
30193 {
30194         if (flags & NDR_IN) {
30195         }
30196         if (flags & NDR_OUT) {
30197                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30198         }
30199         return NDR_ERR_SUCCESS;
30200 }
30201
30202 static enum ndr_err_code ndr_pull_spoolss_6a(struct ndr_pull *ndr, int flags, struct spoolss_6a *r)
30203 {
30204         if (flags & NDR_IN) {
30205         }
30206         if (flags & NDR_OUT) {
30207                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30208         }
30209         return NDR_ERR_SUCCESS;
30210 }
30211
30212 _PUBLIC_ void ndr_print_spoolss_6a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6a *r)
30213 {
30214         ndr_print_struct(ndr, name, "spoolss_6a");
30215         ndr->depth++;
30216         if (flags & NDR_SET_VALUES) {
30217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30218         }
30219         if (flags & NDR_IN) {
30220                 ndr_print_struct(ndr, "in", "spoolss_6a");
30221                 ndr->depth++;
30222                 ndr->depth--;
30223         }
30224         if (flags & NDR_OUT) {
30225                 ndr_print_struct(ndr, "out", "spoolss_6a");
30226                 ndr->depth++;
30227                 ndr_print_WERROR(ndr, "result", r->out.result);
30228                 ndr->depth--;
30229         }
30230         ndr->depth--;
30231 }
30232
30233 static enum ndr_err_code ndr_push_spoolss_6b(struct ndr_push *ndr, int flags, const struct spoolss_6b *r)
30234 {
30235         if (flags & NDR_IN) {
30236         }
30237         if (flags & NDR_OUT) {
30238                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30239         }
30240         return NDR_ERR_SUCCESS;
30241 }
30242
30243 static enum ndr_err_code ndr_pull_spoolss_6b(struct ndr_pull *ndr, int flags, struct spoolss_6b *r)
30244 {
30245         if (flags & NDR_IN) {
30246         }
30247         if (flags & NDR_OUT) {
30248                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30249         }
30250         return NDR_ERR_SUCCESS;
30251 }
30252
30253 _PUBLIC_ void ndr_print_spoolss_6b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6b *r)
30254 {
30255         ndr_print_struct(ndr, name, "spoolss_6b");
30256         ndr->depth++;
30257         if (flags & NDR_SET_VALUES) {
30258                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30259         }
30260         if (flags & NDR_IN) {
30261                 ndr_print_struct(ndr, "in", "spoolss_6b");
30262                 ndr->depth++;
30263                 ndr->depth--;
30264         }
30265         if (flags & NDR_OUT) {
30266                 ndr_print_struct(ndr, "out", "spoolss_6b");
30267                 ndr->depth++;
30268                 ndr_print_WERROR(ndr, "result", r->out.result);
30269                 ndr->depth--;
30270         }
30271         ndr->depth--;
30272 }
30273
30274 static enum ndr_err_code ndr_push_spoolss_6c(struct ndr_push *ndr, int flags, const struct spoolss_6c *r)
30275 {
30276         if (flags & NDR_IN) {
30277         }
30278         if (flags & NDR_OUT) {
30279                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30280         }
30281         return NDR_ERR_SUCCESS;
30282 }
30283
30284 static enum ndr_err_code ndr_pull_spoolss_6c(struct ndr_pull *ndr, int flags, struct spoolss_6c *r)
30285 {
30286         if (flags & NDR_IN) {
30287         }
30288         if (flags & NDR_OUT) {
30289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30290         }
30291         return NDR_ERR_SUCCESS;
30292 }
30293
30294 _PUBLIC_ void ndr_print_spoolss_6c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6c *r)
30295 {
30296         ndr_print_struct(ndr, name, "spoolss_6c");
30297         ndr->depth++;
30298         if (flags & NDR_SET_VALUES) {
30299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30300         }
30301         if (flags & NDR_IN) {
30302                 ndr_print_struct(ndr, "in", "spoolss_6c");
30303                 ndr->depth++;
30304                 ndr->depth--;
30305         }
30306         if (flags & NDR_OUT) {
30307                 ndr_print_struct(ndr, "out", "spoolss_6c");
30308                 ndr->depth++;
30309                 ndr_print_WERROR(ndr, "result", r->out.result);
30310                 ndr->depth--;
30311         }
30312         ndr->depth--;
30313 }
30314
30315 static enum ndr_err_code ndr_push_spoolss_6d(struct ndr_push *ndr, int flags, const struct spoolss_6d *r)
30316 {
30317         if (flags & NDR_IN) {
30318         }
30319         if (flags & NDR_OUT) {
30320                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
30321         }
30322         return NDR_ERR_SUCCESS;
30323 }
30324
30325 static enum ndr_err_code ndr_pull_spoolss_6d(struct ndr_pull *ndr, int flags, struct spoolss_6d *r)
30326 {
30327         if (flags & NDR_IN) {
30328         }
30329         if (flags & NDR_OUT) {
30330                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
30331         }
30332         return NDR_ERR_SUCCESS;
30333 }
30334
30335 _PUBLIC_ void ndr_print_spoolss_6d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_6d *r)
30336 {
30337         ndr_print_struct(ndr, name, "spoolss_6d");
30338         ndr->depth++;
30339         if (flags & NDR_SET_VALUES) {
30340                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
30341         }
30342         if (flags & NDR_IN) {
30343                 ndr_print_struct(ndr, "in", "spoolss_6d");
30344                 ndr->depth++;
30345                 ndr->depth--;
30346         }
30347         if (flags & NDR_OUT) {
30348                 ndr_print_struct(ndr, "out", "spoolss_6d");
30349                 ndr->depth++;
30350                 ndr_print_WERROR(ndr, "result", r->out.result);
30351                 ndr->depth--;
30352         }
30353         ndr->depth--;
30354 }
30355
30356 static const struct ndr_interface_call spoolss_calls[] = {
30357         {
30358                 "spoolss_EnumPrinters",
30359                 sizeof(struct spoolss_EnumPrinters),
30360                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
30361                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
30362                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
30363                 false,
30364         },
30365         {
30366                 "spoolss_OpenPrinter",
30367                 sizeof(struct spoolss_OpenPrinter),
30368                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
30369                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
30370                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
30371                 false,
30372         },
30373         {
30374                 "spoolss_SetJob",
30375                 sizeof(struct spoolss_SetJob),
30376                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
30377                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
30378                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
30379                 false,
30380         },
30381         {
30382                 "spoolss_GetJob",
30383                 sizeof(struct spoolss_GetJob),
30384                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
30385                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
30386                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
30387                 false,
30388         },
30389         {
30390                 "spoolss_EnumJobs",
30391                 sizeof(struct spoolss_EnumJobs),
30392                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
30393                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
30394                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
30395                 false,
30396         },
30397         {
30398                 "spoolss_AddPrinter",
30399                 sizeof(struct spoolss_AddPrinter),
30400                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
30401                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
30402                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
30403                 false,
30404         },
30405         {
30406                 "spoolss_DeletePrinter",
30407                 sizeof(struct spoolss_DeletePrinter),
30408                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
30409                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
30410                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
30411                 false,
30412         },
30413         {
30414                 "spoolss_SetPrinter",
30415                 sizeof(struct spoolss_SetPrinter),
30416                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
30417                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
30418                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
30419                 false,
30420         },
30421         {
30422                 "spoolss_GetPrinter",
30423                 sizeof(struct spoolss_GetPrinter),
30424                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
30425                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
30426                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
30427                 false,
30428         },
30429         {
30430                 "spoolss_AddPrinterDriver",
30431                 sizeof(struct spoolss_AddPrinterDriver),
30432                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
30433                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
30434                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
30435                 false,
30436         },
30437         {
30438                 "spoolss_EnumPrinterDrivers",
30439                 sizeof(struct spoolss_EnumPrinterDrivers),
30440                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
30441                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
30442                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
30443                 false,
30444         },
30445         {
30446                 "spoolss_GetPrinterDriver",
30447                 sizeof(struct spoolss_GetPrinterDriver),
30448                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
30449                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
30450                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
30451                 false,
30452         },
30453         {
30454                 "spoolss_GetPrinterDriverDirectory",
30455                 sizeof(struct spoolss_GetPrinterDriverDirectory),
30456                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
30457                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
30458                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
30459                 false,
30460         },
30461         {
30462                 "spoolss_DeletePrinterDriver",
30463                 sizeof(struct spoolss_DeletePrinterDriver),
30464                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
30465                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
30466                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
30467                 false,
30468         },
30469         {
30470                 "spoolss_AddPrintProcessor",
30471                 sizeof(struct spoolss_AddPrintProcessor),
30472                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
30473                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
30474                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
30475                 false,
30476         },
30477         {
30478                 "spoolss_EnumPrintProcessors",
30479                 sizeof(struct spoolss_EnumPrintProcessors),
30480                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
30481                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
30482                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
30483                 false,
30484         },
30485         {
30486                 "spoolss_GetPrintProcessorDirectory",
30487                 sizeof(struct spoolss_GetPrintProcessorDirectory),
30488                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
30489                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
30490                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
30491                 false,
30492         },
30493         {
30494                 "spoolss_StartDocPrinter",
30495                 sizeof(struct spoolss_StartDocPrinter),
30496                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
30497                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
30498                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
30499                 false,
30500         },
30501         {
30502                 "spoolss_StartPagePrinter",
30503                 sizeof(struct spoolss_StartPagePrinter),
30504                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
30505                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
30506                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
30507                 false,
30508         },
30509         {
30510                 "spoolss_WritePrinter",
30511                 sizeof(struct spoolss_WritePrinter),
30512                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
30513                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
30514                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
30515                 false,
30516         },
30517         {
30518                 "spoolss_EndPagePrinter",
30519                 sizeof(struct spoolss_EndPagePrinter),
30520                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
30521                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
30522                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
30523                 false,
30524         },
30525         {
30526                 "spoolss_AbortPrinter",
30527                 sizeof(struct spoolss_AbortPrinter),
30528                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
30529                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
30530                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
30531                 false,
30532         },
30533         {
30534                 "spoolss_ReadPrinter",
30535                 sizeof(struct spoolss_ReadPrinter),
30536                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
30537                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
30538                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
30539                 false,
30540         },
30541         {
30542                 "spoolss_EndDocPrinter",
30543                 sizeof(struct spoolss_EndDocPrinter),
30544                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
30545                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
30546                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
30547                 false,
30548         },
30549         {
30550                 "spoolss_AddJob",
30551                 sizeof(struct spoolss_AddJob),
30552                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
30553                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
30554                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
30555                 false,
30556         },
30557         {
30558                 "spoolss_ScheduleJob",
30559                 sizeof(struct spoolss_ScheduleJob),
30560                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
30561                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
30562                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
30563                 false,
30564         },
30565         {
30566                 "spoolss_GetPrinterData",
30567                 sizeof(struct spoolss_GetPrinterData),
30568                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
30569                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
30570                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
30571                 false,
30572         },
30573         {
30574                 "spoolss_SetPrinterData",
30575                 sizeof(struct spoolss_SetPrinterData),
30576                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
30577                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
30578                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
30579                 false,
30580         },
30581         {
30582                 "spoolss_WaitForPrinterChange",
30583                 sizeof(struct spoolss_WaitForPrinterChange),
30584                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
30585                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
30586                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
30587                 false,
30588         },
30589         {
30590                 "spoolss_ClosePrinter",
30591                 sizeof(struct spoolss_ClosePrinter),
30592                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
30593                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
30594                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
30595                 false,
30596         },
30597         {
30598                 "spoolss_AddForm",
30599                 sizeof(struct spoolss_AddForm),
30600                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
30601                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
30602                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
30603                 false,
30604         },
30605         {
30606                 "spoolss_DeleteForm",
30607                 sizeof(struct spoolss_DeleteForm),
30608                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
30609                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
30610                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
30611                 false,
30612         },
30613         {
30614                 "spoolss_GetForm",
30615                 sizeof(struct spoolss_GetForm),
30616                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
30617                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
30618                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
30619                 false,
30620         },
30621         {
30622                 "spoolss_SetForm",
30623                 sizeof(struct spoolss_SetForm),
30624                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
30625                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
30626                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
30627                 false,
30628         },
30629         {
30630                 "spoolss_EnumForms",
30631                 sizeof(struct spoolss_EnumForms),
30632                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
30633                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
30634                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
30635                 false,
30636         },
30637         {
30638                 "spoolss_EnumPorts",
30639                 sizeof(struct spoolss_EnumPorts),
30640                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
30641                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
30642                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
30643                 false,
30644         },
30645         {
30646                 "spoolss_EnumMonitors",
30647                 sizeof(struct spoolss_EnumMonitors),
30648                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
30649                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
30650                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
30651                 false,
30652         },
30653         {
30654                 "spoolss_AddPort",
30655                 sizeof(struct spoolss_AddPort),
30656                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
30657                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
30658                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
30659                 false,
30660         },
30661         {
30662                 "spoolss_ConfigurePort",
30663                 sizeof(struct spoolss_ConfigurePort),
30664                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
30665                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
30666                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
30667                 false,
30668         },
30669         {
30670                 "spoolss_DeletePort",
30671                 sizeof(struct spoolss_DeletePort),
30672                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
30673                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
30674                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
30675                 false,
30676         },
30677         {
30678                 "spoolss_CreatePrinterIC",
30679                 sizeof(struct spoolss_CreatePrinterIC),
30680                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
30681                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
30682                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
30683                 false,
30684         },
30685         {
30686                 "spoolss_PlayGDIScriptOnPrinterIC",
30687                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
30688                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
30689                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
30690                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
30691                 false,
30692         },
30693         {
30694                 "spoolss_DeletePrinterIC",
30695                 sizeof(struct spoolss_DeletePrinterIC),
30696                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
30697                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
30698                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
30699                 false,
30700         },
30701         {
30702                 "spoolss_AddPrinterConnection",
30703                 sizeof(struct spoolss_AddPrinterConnection),
30704                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
30705                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
30706                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
30707                 false,
30708         },
30709         {
30710                 "spoolss_DeletePrinterConnection",
30711                 sizeof(struct spoolss_DeletePrinterConnection),
30712                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
30713                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
30714                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
30715                 false,
30716         },
30717         {
30718                 "spoolss_PrinterMessageBox",
30719                 sizeof(struct spoolss_PrinterMessageBox),
30720                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
30721                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
30722                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
30723                 false,
30724         },
30725         {
30726                 "spoolss_AddMonitor",
30727                 sizeof(struct spoolss_AddMonitor),
30728                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
30729                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
30730                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
30731                 false,
30732         },
30733         {
30734                 "spoolss_DeleteMonitor",
30735                 sizeof(struct spoolss_DeleteMonitor),
30736                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
30737                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
30738                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
30739                 false,
30740         },
30741         {
30742                 "spoolss_DeletePrintProcessor",
30743                 sizeof(struct spoolss_DeletePrintProcessor),
30744                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
30745                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
30746                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
30747                 false,
30748         },
30749         {
30750                 "spoolss_AddPrintProvidor",
30751                 sizeof(struct spoolss_AddPrintProvidor),
30752                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
30753                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
30754                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
30755                 false,
30756         },
30757         {
30758                 "spoolss_DeletePrintProvidor",
30759                 sizeof(struct spoolss_DeletePrintProvidor),
30760                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
30761                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
30762                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
30763                 false,
30764         },
30765         {
30766                 "spoolss_EnumPrintProcDataTypes",
30767                 sizeof(struct spoolss_EnumPrintProcDataTypes),
30768                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
30769                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
30770                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
30771                 false,
30772         },
30773         {
30774                 "spoolss_ResetPrinter",
30775                 sizeof(struct spoolss_ResetPrinter),
30776                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
30777                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
30778                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
30779                 false,
30780         },
30781         {
30782                 "spoolss_GetPrinterDriver2",
30783                 sizeof(struct spoolss_GetPrinterDriver2),
30784                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
30785                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
30786                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
30787                 false,
30788         },
30789         {
30790                 "spoolss_FindFirstPrinterChangeNotification",
30791                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
30792                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
30793                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
30794                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
30795                 false,
30796         },
30797         {
30798                 "spoolss_FindNextPrinterChangeNotification",
30799                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
30800                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
30801                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
30802                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
30803                 false,
30804         },
30805         {
30806                 "spoolss_FindClosePrinterNotify",
30807                 sizeof(struct spoolss_FindClosePrinterNotify),
30808                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
30809                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
30810                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
30811                 false,
30812         },
30813         {
30814                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
30815                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
30816                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30817                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30818                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
30819                 false,
30820         },
30821         {
30822                 "spoolss_ReplyOpenPrinter",
30823                 sizeof(struct spoolss_ReplyOpenPrinter),
30824                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
30825                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
30826                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
30827                 false,
30828         },
30829         {
30830                 "spoolss_RouterReplyPrinter",
30831                 sizeof(struct spoolss_RouterReplyPrinter),
30832                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
30833                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
30834                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
30835                 false,
30836         },
30837         {
30838                 "spoolss_ReplyClosePrinter",
30839                 sizeof(struct spoolss_ReplyClosePrinter),
30840                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
30841                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
30842                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
30843                 false,
30844         },
30845         {
30846                 "spoolss_AddPortEx",
30847                 sizeof(struct spoolss_AddPortEx),
30848                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
30849                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
30850                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
30851                 false,
30852         },
30853         {
30854                 "spoolss_RouterFindFirstPrinterChangeNotification",
30855                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
30856                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
30857                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
30858                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
30859                 false,
30860         },
30861         {
30862                 "spoolss_SpoolerInit",
30863                 sizeof(struct spoolss_SpoolerInit),
30864                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
30865                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
30866                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
30867                 false,
30868         },
30869         {
30870                 "spoolss_ResetPrinterEx",
30871                 sizeof(struct spoolss_ResetPrinterEx),
30872                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
30873                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
30874                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
30875                 false,
30876         },
30877         {
30878                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
30879                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
30880                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30881                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30882                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
30883                 false,
30884         },
30885         {
30886                 "spoolss_RouterReplyPrinterEx",
30887                 sizeof(struct spoolss_RouterReplyPrinterEx),
30888                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
30889                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
30890                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
30891                 false,
30892         },
30893         {
30894                 "spoolss_RouterRefreshPrinterChangeNotify",
30895                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
30896                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
30897                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
30898                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
30899                 false,
30900         },
30901         {
30902                 "spoolss_44",
30903                 sizeof(struct spoolss_44),
30904                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
30905                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
30906                 (ndr_print_function_t) ndr_print_spoolss_44,
30907                 false,
30908         },
30909         {
30910                 "spoolss_OpenPrinterEx",
30911                 sizeof(struct spoolss_OpenPrinterEx),
30912                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
30913                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
30914                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
30915                 false,
30916         },
30917         {
30918                 "spoolss_AddPrinterEx",
30919                 sizeof(struct spoolss_AddPrinterEx),
30920                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
30921                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
30922                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
30923                 false,
30924         },
30925         {
30926                 "spoolss_47",
30927                 sizeof(struct spoolss_47),
30928                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
30929                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
30930                 (ndr_print_function_t) ndr_print_spoolss_47,
30931                 false,
30932         },
30933         {
30934                 "spoolss_EnumPrinterData",
30935                 sizeof(struct spoolss_EnumPrinterData),
30936                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
30937                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
30938                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
30939                 false,
30940         },
30941         {
30942                 "spoolss_DeletePrinterData",
30943                 sizeof(struct spoolss_DeletePrinterData),
30944                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
30945                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
30946                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
30947                 false,
30948         },
30949         {
30950                 "spoolss_4a",
30951                 sizeof(struct spoolss_4a),
30952                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
30953                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
30954                 (ndr_print_function_t) ndr_print_spoolss_4a,
30955                 false,
30956         },
30957         {
30958                 "spoolss_4b",
30959                 sizeof(struct spoolss_4b),
30960                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
30961                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
30962                 (ndr_print_function_t) ndr_print_spoolss_4b,
30963                 false,
30964         },
30965         {
30966                 "spoolss_4c",
30967                 sizeof(struct spoolss_4c),
30968                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
30969                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
30970                 (ndr_print_function_t) ndr_print_spoolss_4c,
30971                 false,
30972         },
30973         {
30974                 "spoolss_SetPrinterDataEx",
30975                 sizeof(struct spoolss_SetPrinterDataEx),
30976                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
30977                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
30978                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
30979                 false,
30980         },
30981         {
30982                 "spoolss_GetPrinterDataEx",
30983                 sizeof(struct spoolss_GetPrinterDataEx),
30984                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
30985                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
30986                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
30987                 false,
30988         },
30989         {
30990                 "spoolss_EnumPrinterDataEx",
30991                 sizeof(struct spoolss_EnumPrinterDataEx),
30992                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
30993                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
30994                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
30995                 false,
30996         },
30997         {
30998                 "spoolss_EnumPrinterKey",
30999                 sizeof(struct spoolss_EnumPrinterKey),
31000                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
31001                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
31002                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
31003                 false,
31004         },
31005         {
31006                 "spoolss_DeletePrinterDataEx",
31007                 sizeof(struct spoolss_DeletePrinterDataEx),
31008                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
31009                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
31010                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
31011                 false,
31012         },
31013         {
31014                 "spoolss_DeletePrinterKey",
31015                 sizeof(struct spoolss_DeletePrinterKey),
31016                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
31017                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
31018                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
31019                 false,
31020         },
31021         {
31022                 "spoolss_53",
31023                 sizeof(struct spoolss_53),
31024                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
31025                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
31026                 (ndr_print_function_t) ndr_print_spoolss_53,
31027                 false,
31028         },
31029         {
31030                 "spoolss_DeletePrinterDriverEx",
31031                 sizeof(struct spoolss_DeletePrinterDriverEx),
31032                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
31033                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
31034                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
31035                 false,
31036         },
31037         {
31038                 "spoolss_55",
31039                 sizeof(struct spoolss_55),
31040                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
31041                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
31042                 (ndr_print_function_t) ndr_print_spoolss_55,
31043                 false,
31044         },
31045         {
31046                 "spoolss_56",
31047                 sizeof(struct spoolss_56),
31048                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
31049                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
31050                 (ndr_print_function_t) ndr_print_spoolss_56,
31051                 false,
31052         },
31053         {
31054                 "spoolss_57",
31055                 sizeof(struct spoolss_57),
31056                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
31057                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
31058                 (ndr_print_function_t) ndr_print_spoolss_57,
31059                 false,
31060         },
31061         {
31062                 "spoolss_XcvData",
31063                 sizeof(struct spoolss_XcvData),
31064                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
31065                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
31066                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
31067                 false,
31068         },
31069         {
31070                 "spoolss_AddPrinterDriverEx",
31071                 sizeof(struct spoolss_AddPrinterDriverEx),
31072                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
31073                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
31074                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
31075                 false,
31076         },
31077         {
31078                 "spoolss_5a",
31079                 sizeof(struct spoolss_5a),
31080                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
31081                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
31082                 (ndr_print_function_t) ndr_print_spoolss_5a,
31083                 false,
31084         },
31085         {
31086                 "spoolss_5b",
31087                 sizeof(struct spoolss_5b),
31088                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
31089                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
31090                 (ndr_print_function_t) ndr_print_spoolss_5b,
31091                 false,
31092         },
31093         {
31094                 "spoolss_5c",
31095                 sizeof(struct spoolss_5c),
31096                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
31097                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
31098                 (ndr_print_function_t) ndr_print_spoolss_5c,
31099                 false,
31100         },
31101         {
31102                 "spoolss_5d",
31103                 sizeof(struct spoolss_5d),
31104                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
31105                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
31106                 (ndr_print_function_t) ndr_print_spoolss_5d,
31107                 false,
31108         },
31109         {
31110                 "spoolss_5e",
31111                 sizeof(struct spoolss_5e),
31112                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
31113                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
31114                 (ndr_print_function_t) ndr_print_spoolss_5e,
31115                 false,
31116         },
31117         {
31118                 "spoolss_5f",
31119                 sizeof(struct spoolss_5f),
31120                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
31121                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
31122                 (ndr_print_function_t) ndr_print_spoolss_5f,
31123                 false,
31124         },
31125         {
31126                 "spoolss_60",
31127                 sizeof(struct spoolss_60),
31128                 (ndr_push_flags_fn_t) ndr_push_spoolss_60,
31129                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_60,
31130                 (ndr_print_function_t) ndr_print_spoolss_60,
31131                 false,
31132         },
31133         {
31134                 "spoolss_61",
31135                 sizeof(struct spoolss_61),
31136                 (ndr_push_flags_fn_t) ndr_push_spoolss_61,
31137                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_61,
31138                 (ndr_print_function_t) ndr_print_spoolss_61,
31139                 false,
31140         },
31141         {
31142                 "spoolss_62",
31143                 sizeof(struct spoolss_62),
31144                 (ndr_push_flags_fn_t) ndr_push_spoolss_62,
31145                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_62,
31146                 (ndr_print_function_t) ndr_print_spoolss_62,
31147                 false,
31148         },
31149         {
31150                 "spoolss_63",
31151                 sizeof(struct spoolss_63),
31152                 (ndr_push_flags_fn_t) ndr_push_spoolss_63,
31153                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_63,
31154                 (ndr_print_function_t) ndr_print_spoolss_63,
31155                 false,
31156         },
31157         {
31158                 "spoolss_64",
31159                 sizeof(struct spoolss_64),
31160                 (ndr_push_flags_fn_t) ndr_push_spoolss_64,
31161                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_64,
31162                 (ndr_print_function_t) ndr_print_spoolss_64,
31163                 false,
31164         },
31165         {
31166                 "spoolss_65",
31167                 sizeof(struct spoolss_65),
31168                 (ndr_push_flags_fn_t) ndr_push_spoolss_65,
31169                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_65,
31170                 (ndr_print_function_t) ndr_print_spoolss_65,
31171                 false,
31172         },
31173         {
31174                 "spoolss_GetCorePrinterDrivers",
31175                 sizeof(struct spoolss_GetCorePrinterDrivers),
31176                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetCorePrinterDrivers,
31177                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetCorePrinterDrivers,
31178                 (ndr_print_function_t) ndr_print_spoolss_GetCorePrinterDrivers,
31179                 false,
31180         },
31181         {
31182                 "spoolss_67",
31183                 sizeof(struct spoolss_67),
31184                 (ndr_push_flags_fn_t) ndr_push_spoolss_67,
31185                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_67,
31186                 (ndr_print_function_t) ndr_print_spoolss_67,
31187                 false,
31188         },
31189         {
31190                 "spoolss_GetPrinterDriverPackagePath",
31191                 sizeof(struct spoolss_GetPrinterDriverPackagePath),
31192                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverPackagePath,
31193                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverPackagePath,
31194                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverPackagePath,
31195                 false,
31196         },
31197         {
31198                 "spoolss_69",
31199                 sizeof(struct spoolss_69),
31200                 (ndr_push_flags_fn_t) ndr_push_spoolss_69,
31201                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_69,
31202                 (ndr_print_function_t) ndr_print_spoolss_69,
31203                 false,
31204         },
31205         {
31206                 "spoolss_6a",
31207                 sizeof(struct spoolss_6a),
31208                 (ndr_push_flags_fn_t) ndr_push_spoolss_6a,
31209                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6a,
31210                 (ndr_print_function_t) ndr_print_spoolss_6a,
31211                 false,
31212         },
31213         {
31214                 "spoolss_6b",
31215                 sizeof(struct spoolss_6b),
31216                 (ndr_push_flags_fn_t) ndr_push_spoolss_6b,
31217                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6b,
31218                 (ndr_print_function_t) ndr_print_spoolss_6b,
31219                 false,
31220         },
31221         {
31222                 "spoolss_6c",
31223                 sizeof(struct spoolss_6c),
31224                 (ndr_push_flags_fn_t) ndr_push_spoolss_6c,
31225                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6c,
31226                 (ndr_print_function_t) ndr_print_spoolss_6c,
31227                 false,
31228         },
31229         {
31230                 "spoolss_6d",
31231                 sizeof(struct spoolss_6d),
31232                 (ndr_push_flags_fn_t) ndr_push_spoolss_6d,
31233                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_6d,
31234                 (ndr_print_function_t) ndr_print_spoolss_6d,
31235                 false,
31236         },
31237         { NULL, 0, NULL, NULL, NULL, false }
31238 };
31239
31240 static const char * const spoolss_endpoint_strings[] = {
31241         "ncacn_np:[\\pipe\\spoolss]",
31242 };
31243
31244 static const struct ndr_interface_string_array spoolss_endpoints = {
31245         .count  = 1,
31246         .names  = spoolss_endpoint_strings
31247 };
31248
31249 static const char * const spoolss_authservice_strings[] = {
31250         "host",
31251 };
31252
31253 static const struct ndr_interface_string_array spoolss_authservices = {
31254         .count  = 1,
31255         .names  = spoolss_authservice_strings
31256 };
31257
31258
31259 const struct ndr_interface_table ndr_table_spoolss = {
31260         .name           = "spoolss",
31261         .syntax_id      = {
31262                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
31263                 NDR_SPOOLSS_VERSION
31264         },
31265         .helpstring     = NDR_SPOOLSS_HELPSTRING,
31266         .num_calls      = 110,
31267         .calls          = spoolss_calls,
31268         .endpoints      = &spoolss_endpoints,
31269         .authservices   = &spoolss_authservices
31270 };
31271