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         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 516 {
 517         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 522 {
 523         uint32_t v;
 524         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 525         *r = v;
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 530 {
 531         ndr_print_uint32(ndr, name, r);
 532         ndr->depth++;
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 561         ndr->depth--;
 562 }
 563
 564 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 565 {
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_push_align(ndr, 4));
 568                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 569                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 571                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 572                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 573                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 602                 {
 603                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 605                         {
 606                                 struct ndr_push *_ndr_driverextra_data;
 607                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 608                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 609                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 610                         }
 611                         ndr->flags = _flags_save_DATA_BLOB;
 612                 }
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_pull_align(ndr, 4));
 623                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 624                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 625                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 626                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 627                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 628                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 633                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 642                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 657                 {
 658                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 660                         {
 661                                 struct ndr_pull *_ndr_driverextra_data;
 662                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 663                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 664                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 665                         }
 666                         ndr->flags = _flags_save_DATA_BLOB;
 667                 }
 668         }
 669         if (ndr_flags & NDR_BUFFERS) {
 670         }
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 675 {
 676         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 677         ndr->depth++;
 678         ndr_print_string(ndr, "devicename", r->devicename);
 679         ndr_print_uint16(ndr, "specversion", r->specversion);
 680         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 681         ndr_print_uint16(ndr, "size", r->size);
 682         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 683         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 684         ndr_print_uint16(ndr, "orientation", r->orientation);
 685         ndr_print_uint16(ndr, "papersize", r->papersize);
 686         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 687         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 688         ndr_print_uint16(ndr, "scale", r->scale);
 689         ndr_print_uint16(ndr, "copies", r->copies);
 690         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 691         ndr_print_uint16(ndr, "printquality", r->printquality);
 692         ndr_print_uint16(ndr, "color", r->color);
 693         ndr_print_uint16(ndr, "duplex", r->duplex);
 694         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 695         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 696         ndr_print_uint16(ndr, "collate", r->collate);
 697         ndr_print_string(ndr, "formname", r->formname);
 698         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 699         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 700         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 701         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 702         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 703         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 704         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 705         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 706         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 707         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 708         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 709         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 710         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 711         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 712         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 713         ndr->depth--;
 714 }
 715
 716 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 717 {
 718         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 719 }
 720
 721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 722 {
 723         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 724         return NDR_ERR_SUCCESS;
 725 }
 726
 727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 728 {
 729         uint32_t v;
 730         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 731         *r = v;
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 736 {
 737         ndr_print_uint32(ndr, name, r);
 738         ndr->depth++;
 739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 758         ndr->depth--;
 759 }
 760
 761 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_push_align(ndr, 4));
 765                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 766                 {
 767                         uint32_t _flags_save_string = ndr->flags;
 768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 776                         ndr->flags = _flags_save_string;
 777                 }
 778                 {
 779                         uint32_t _flags_save_string = ndr->flags;
 780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 792                         }
 793                         ndr->flags = _flags_save_string;
 794                 }
 795                 {
 796                         uint32_t _flags_save_string = ndr->flags;
 797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 798                         if (r->description) {
 799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 801                         }
 802                         ndr->flags = _flags_save_string;
 803                 }
 804                 {
 805                         uint32_t _flags_save_string = ndr->flags;
 806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 807                         if (r->comment) {
 808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 810                         }
 811                         ndr->flags = _flags_save_string;
 812                 }
 813         }
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 818 {
 819         uint32_t _ptr_name;
 820         TALLOC_CTX *_mem_save_name_0;
 821         uint32_t _ptr_description;
 822         TALLOC_CTX *_mem_save_description_0;
 823         uint32_t _ptr_comment;
 824         TALLOC_CTX *_mem_save_comment_0;
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 4));
 827                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 828                 {
 829                         uint32_t _flags_save_string = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 832                         if (_ptr_name) {
 833                                 NDR_PULL_ALLOC(ndr, r->name);
 834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 835                         } else {
 836                                 r->name = NULL;
 837                         }
 838                         ndr->flags = _flags_save_string;
 839                 }
 840                 {
 841                         uint32_t _flags_save_string = ndr->flags;
 842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 844                         if (_ptr_description) {
 845                                 NDR_PULL_ALLOC(ndr, r->description);
 846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 847                         } else {
 848                                 r->description = NULL;
 849                         }
 850                         ndr->flags = _flags_save_string;
 851                 }
 852                 {
 853                         uint32_t _flags_save_string = ndr->flags;
 854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 856                         if (_ptr_comment) {
 857                                 NDR_PULL_ALLOC(ndr, r->comment);
 858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 859                         } else {
 860                                 r->comment = NULL;
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864         }
 865         if (ndr_flags & NDR_BUFFERS) {
 866                 {
 867                         uint32_t _flags_save_string = ndr->flags;
 868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 869                         if (r->name) {
 870                                 uint32_t _relative_save_offset;
 871                                 _relative_save_offset = ndr->offset;
 872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 873                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 874                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 877                                 ndr->offset = _relative_save_offset;
 878                         }
 879                         ndr->flags = _flags_save_string;
 880                 }
 881                 {
 882                         uint32_t _flags_save_string = ndr->flags;
 883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 884                         if (r->description) {
 885                                 uint32_t _relative_save_offset;
 886                                 _relative_save_offset = ndr->offset;
 887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 888                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 892                                 ndr->offset = _relative_save_offset;
 893                         }
 894                         ndr->flags = _flags_save_string;
 895                 }
 896                 {
 897                         uint32_t _flags_save_string = ndr->flags;
 898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 899                         if (r->comment) {
 900                                 uint32_t _relative_save_offset;
 901                                 _relative_save_offset = ndr->offset;
 902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 903                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 907                                 ndr->offset = _relative_save_offset;
 908                         }
 909                         ndr->flags = _flags_save_string;
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 916 {
 917         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 918         ndr->depth++;
 919         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 920         ndr_print_ptr(ndr, "name", r->name);
 921         ndr->depth++;
 922         if (r->name) {
 923                 ndr_print_string(ndr, "name", r->name);
 924         }
 925         ndr->depth--;
 926         ndr_print_ptr(ndr, "description", r->description);
 927         ndr->depth++;
 928         if (r->description) {
 929                 ndr_print_string(ndr, "description", r->description);
 930         }
 931         ndr->depth--;
 932         ndr_print_ptr(ndr, "comment", r->comment);
 933         ndr->depth++;
 934         if (r->comment) {
 935                 ndr_print_string(ndr, "comment", r->comment);
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 942 {
 943         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944         return NDR_ERR_SUCCESS;
 945 }
 946
 947 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 948 {
 949         uint32_t v;
 950         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 951         *r = v;
 952         return NDR_ERR_SUCCESS;
 953 }
 954
 955 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 956 {
 957         ndr_print_uint32(ndr, name, r);
 958         ndr->depth++;
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 975         ndr->depth--;
 976 }
 977
 978 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 979 {
 980         if (ndr_flags & NDR_SCALARS) {
 981                 NDR_CHECK(ndr_push_align(ndr, 4));
 982                 {
 983                         uint32_t _flags_save_string = ndr->flags;
 984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 986                         ndr->flags = _flags_save_string;
 987                 }
 988                 {
 989                         uint32_t _flags_save_string = ndr->flags;
 990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 991                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 992                         ndr->flags = _flags_save_string;
 993                 }
 994                 {
 995                         uint32_t _flags_save_string = ndr->flags;
 996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 998                         ndr->flags = _flags_save_string;
 999                 }
1000                 {
1001                         uint32_t _flags_save_string = ndr->flags;
1002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1003                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1004                         ndr->flags = _flags_save_string;
1005                 }
1006                 {
1007                         uint32_t _flags_save_string = ndr->flags;
1008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1009                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1010                         ndr->flags = _flags_save_string;
1011                 }
1012                 {
1013                         uint32_t _flags_save_string = ndr->flags;
1014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1015                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1016                         ndr->flags = _flags_save_string;
1017                 }
1018                 {
1019                         uint32_t _flags_save_string = ndr->flags;
1020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1022                         ndr->flags = _flags_save_string;
1023                 }
1024                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1025                 {
1026                         uint32_t _flags_save_string = ndr->flags;
1027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1029                         ndr->flags = _flags_save_string;
1030                 }
1031                 {
1032                         uint32_t _flags_save_string = ndr->flags;
1033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1034                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1035                         ndr->flags = _flags_save_string;
1036                 }
1037                 {
1038                         uint32_t _flags_save_string = ndr->flags;
1039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1041                         ndr->flags = _flags_save_string;
1042                 }
1043                 {
1044                         uint32_t _flags_save_string = ndr->flags;
1045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1047                         ndr->flags = _flags_save_string;
1048                 }
1049                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1050                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1055                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 {
1061                         uint32_t _flags_save_string = ndr->flags;
1062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1063                         if (r->servername) {
1064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1066                         }
1067                         ndr->flags = _flags_save_string;
1068                 }
1069                 {
1070                         uint32_t _flags_save_string = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1072                         if (r->printername) {
1073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1075                         }
1076                         ndr->flags = _flags_save_string;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         if (r->sharename) {
1082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1084                         }
1085                         ndr->flags = _flags_save_string;
1086                 }
1087                 {
1088                         uint32_t _flags_save_string = ndr->flags;
1089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1090                         if (r->portname) {
1091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1093                         }
1094                         ndr->flags = _flags_save_string;
1095                 }
1096                 {
1097                         uint32_t _flags_save_string = ndr->flags;
1098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1099                         if (r->drivername) {
1100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1102                         }
1103                         ndr->flags = _flags_save_string;
1104                 }
1105                 {
1106                         uint32_t _flags_save_string = ndr->flags;
1107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1108                         if (r->comment) {
1109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1111                         }
1112                         ndr->flags = _flags_save_string;
1113                 }
1114                 {
1115                         uint32_t _flags_save_string = ndr->flags;
1116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1117                         if (r->location) {
1118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1119                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1120                         }
1121                         ndr->flags = _flags_save_string;
1122                 }
1123                 if (r->devmode) {
1124                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1125                         {
1126                                 struct ndr_push *_ndr_devmode;
1127                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1128                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1129                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1130                         }
1131                 }
1132                 {
1133                         uint32_t _flags_save_string = ndr->flags;
1134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1135                         if (r->sepfile) {
1136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1138                         }
1139                         ndr->flags = _flags_save_string;
1140                 }
1141                 {
1142                         uint32_t _flags_save_string = ndr->flags;
1143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1144                         if (r->printprocessor) {
1145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1147                         }
1148                         ndr->flags = _flags_save_string;
1149                 }
1150                 {
1151                         uint32_t _flags_save_string = ndr->flags;
1152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1153                         if (r->datatype) {
1154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1156                         }
1157                         ndr->flags = _flags_save_string;
1158                 }
1159                 {
1160                         uint32_t _flags_save_string = ndr->flags;
1161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1162                         if (r->parameters) {
1163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168                 if (r->secdesc) {
1169                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1170                         {
1171                                 struct ndr_push *_ndr_secdesc;
1172                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1173                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1174                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1175                         }
1176                 }
1177         }
1178         return NDR_ERR_SUCCESS;
1179 }
1180
1181 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1182 {
1183         uint32_t _ptr_servername;
1184         TALLOC_CTX *_mem_save_servername_0;
1185         uint32_t _ptr_printername;
1186         TALLOC_CTX *_mem_save_printername_0;
1187         uint32_t _ptr_sharename;
1188         TALLOC_CTX *_mem_save_sharename_0;
1189         uint32_t _ptr_portname;
1190         TALLOC_CTX *_mem_save_portname_0;
1191         uint32_t _ptr_drivername;
1192         TALLOC_CTX *_mem_save_drivername_0;
1193         uint32_t _ptr_comment;
1194         TALLOC_CTX *_mem_save_comment_0;
1195         uint32_t _ptr_location;
1196         TALLOC_CTX *_mem_save_location_0;
1197         uint32_t _ptr_devmode;
1198         TALLOC_CTX *_mem_save_devmode_0;
1199         uint32_t _ptr_sepfile;
1200         TALLOC_CTX *_mem_save_sepfile_0;
1201         uint32_t _ptr_printprocessor;
1202         TALLOC_CTX *_mem_save_printprocessor_0;
1203         uint32_t _ptr_datatype;
1204         TALLOC_CTX *_mem_save_datatype_0;
1205         uint32_t _ptr_parameters;
1206         TALLOC_CTX *_mem_save_parameters_0;
1207         uint32_t _ptr_secdesc;
1208         TALLOC_CTX *_mem_save_secdesc_0;
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 4));
1211                 {
1212                         uint32_t _flags_save_string = ndr->flags;
1213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1215                         if (_ptr_servername) {
1216                                 NDR_PULL_ALLOC(ndr, r->servername);
1217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1218                         } else {
1219                                 r->servername = NULL;
1220                         }
1221                         ndr->flags = _flags_save_string;
1222                 }
1223                 {
1224                         uint32_t _flags_save_string = ndr->flags;
1225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1226                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1227                         if (_ptr_printername) {
1228                                 NDR_PULL_ALLOC(ndr, r->printername);
1229                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1230                         } else {
1231                                 r->printername = NULL;
1232                         }
1233                         ndr->flags = _flags_save_string;
1234                 }
1235                 {
1236                         uint32_t _flags_save_string = ndr->flags;
1237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1239                         if (_ptr_sharename) {
1240                                 NDR_PULL_ALLOC(ndr, r->sharename);
1241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1242                         } else {
1243                                 r->sharename = NULL;
1244                         }
1245                         ndr->flags = _flags_save_string;
1246                 }
1247                 {
1248                         uint32_t _flags_save_string = ndr->flags;
1249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1250                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1251                         if (_ptr_portname) {
1252                                 NDR_PULL_ALLOC(ndr, r->portname);
1253                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1254                         } else {
1255                                 r->portname = NULL;
1256                         }
1257                         ndr->flags = _flags_save_string;
1258                 }
1259                 {
1260                         uint32_t _flags_save_string = ndr->flags;
1261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1263                         if (_ptr_drivername) {
1264                                 NDR_PULL_ALLOC(ndr, r->drivername);
1265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1266                         } else {
1267                                 r->drivername = NULL;
1268                         }
1269                         ndr->flags = _flags_save_string;
1270                 }
1271                 {
1272                         uint32_t _flags_save_string = ndr->flags;
1273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1275                         if (_ptr_comment) {
1276                                 NDR_PULL_ALLOC(ndr, r->comment);
1277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1278                         } else {
1279                                 r->comment = NULL;
1280                         }
1281                         ndr->flags = _flags_save_string;
1282                 }
1283                 {
1284                         uint32_t _flags_save_string = ndr->flags;
1285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1287                         if (_ptr_location) {
1288                                 NDR_PULL_ALLOC(ndr, r->location);
1289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1290                         } else {
1291                                 r->location = NULL;
1292                         }
1293                         ndr->flags = _flags_save_string;
1294                 }
1295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1296                 if (_ptr_devmode) {
1297                         NDR_PULL_ALLOC(ndr, r->devmode);
1298                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1299                 } else {
1300                         r->devmode = NULL;
1301                 }
1302                 {
1303                         uint32_t _flags_save_string = ndr->flags;
1304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1306                         if (_ptr_sepfile) {
1307                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1309                         } else {
1310                                 r->sepfile = NULL;
1311                         }
1312                         ndr->flags = _flags_save_string;
1313                 }
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1318                         if (_ptr_printprocessor) {
1319                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1321                         } else {
1322                                 r->printprocessor = NULL;
1323                         }
1324                         ndr->flags = _flags_save_string;
1325                 }
1326                 {
1327                         uint32_t _flags_save_string = ndr->flags;
1328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1330                         if (_ptr_datatype) {
1331                                 NDR_PULL_ALLOC(ndr, r->datatype);
1332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1333                         } else {
1334                                 r->datatype = NULL;
1335                         }
1336                         ndr->flags = _flags_save_string;
1337                 }
1338                 {
1339                         uint32_t _flags_save_string = ndr->flags;
1340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1342                         if (_ptr_parameters) {
1343                                 NDR_PULL_ALLOC(ndr, r->parameters);
1344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1345                         } else {
1346                                 r->parameters = NULL;
1347                         }
1348                         ndr->flags = _flags_save_string;
1349                 }
1350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1351                 if (_ptr_secdesc) {
1352                         NDR_PULL_ALLOC(ndr, r->secdesc);
1353                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1354                 } else {
1355                         r->secdesc = NULL;
1356                 }
1357                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1362                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1365         }
1366         if (ndr_flags & NDR_BUFFERS) {
1367                 {
1368                         uint32_t _flags_save_string = ndr->flags;
1369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1370                         if (r->servername) {
1371                                 uint32_t _relative_save_offset;
1372                                 _relative_save_offset = ndr->offset;
1373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1374                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1375                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1378                                 ndr->offset = _relative_save_offset;
1379                         }
1380                         ndr->flags = _flags_save_string;
1381                 }
1382                 {
1383                         uint32_t _flags_save_string = ndr->flags;
1384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1385                         if (r->printername) {
1386                                 uint32_t _relative_save_offset;
1387                                 _relative_save_offset = ndr->offset;
1388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1389                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1390                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1393                                 ndr->offset = _relative_save_offset;
1394                         }
1395                         ndr->flags = _flags_save_string;
1396                 }
1397                 {
1398                         uint32_t _flags_save_string = ndr->flags;
1399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1400                         if (r->sharename) {
1401                                 uint32_t _relative_save_offset;
1402                                 _relative_save_offset = ndr->offset;
1403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1404                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1405                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1406                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1408                                 ndr->offset = _relative_save_offset;
1409                         }
1410                         ndr->flags = _flags_save_string;
1411                 }
1412                 {
1413                         uint32_t _flags_save_string = ndr->flags;
1414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1415                         if (r->portname) {
1416                                 uint32_t _relative_save_offset;
1417                                 _relative_save_offset = ndr->offset;
1418                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1419                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1420                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1421                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1422                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1423                                 ndr->offset = _relative_save_offset;
1424                         }
1425                         ndr->flags = _flags_save_string;
1426                 }
1427                 {
1428                         uint32_t _flags_save_string = ndr->flags;
1429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1430                         if (r->drivername) {
1431                                 uint32_t _relative_save_offset;
1432                                 _relative_save_offset = ndr->offset;
1433                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1434                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1435                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1436                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1437                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1438                                 ndr->offset = _relative_save_offset;
1439                         }
1440                         ndr->flags = _flags_save_string;
1441                 }
1442                 {
1443                         uint32_t _flags_save_string = ndr->flags;
1444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1445                         if (r->comment) {
1446                                 uint32_t _relative_save_offset;
1447                                 _relative_save_offset = ndr->offset;
1448                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1449                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1450                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1451                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1452                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1453                                 ndr->offset = _relative_save_offset;
1454                         }
1455                         ndr->flags = _flags_save_string;
1456                 }
1457                 {
1458                         uint32_t _flags_save_string = ndr->flags;
1459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1460                         if (r->location) {
1461                                 uint32_t _relative_save_offset;
1462                                 _relative_save_offset = ndr->offset;
1463                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1464                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1465                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1466                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1467                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1468                                 ndr->offset = _relative_save_offset;
1469                         }
1470                         ndr->flags = _flags_save_string;
1471                 }
1472                 if (r->devmode) {
1473                         uint32_t _relative_save_offset;
1474                         _relative_save_offset = ndr->offset;
1475                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1476                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1477                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1478                         {
1479                                 struct ndr_pull *_ndr_devmode;
1480                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1481                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1482                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1483                         }
1484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1485                         ndr->offset = _relative_save_offset;
1486                 }
1487                 {
1488                         uint32_t _flags_save_string = ndr->flags;
1489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1490                         if (r->sepfile) {
1491                                 uint32_t _relative_save_offset;
1492                                 _relative_save_offset = ndr->offset;
1493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1494                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1498                                 ndr->offset = _relative_save_offset;
1499                         }
1500                         ndr->flags = _flags_save_string;
1501                 }
1502                 {
1503                         uint32_t _flags_save_string = ndr->flags;
1504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1505                         if (r->printprocessor) {
1506                                 uint32_t _relative_save_offset;
1507                                 _relative_save_offset = ndr->offset;
1508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1509                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1510                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1513                                 ndr->offset = _relative_save_offset;
1514                         }
1515                         ndr->flags = _flags_save_string;
1516                 }
1517                 {
1518                         uint32_t _flags_save_string = ndr->flags;
1519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1520                         if (r->datatype) {
1521                                 uint32_t _relative_save_offset;
1522                                 _relative_save_offset = ndr->offset;
1523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1524                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1528                                 ndr->offset = _relative_save_offset;
1529                         }
1530                         ndr->flags = _flags_save_string;
1531                 }
1532                 {
1533                         uint32_t _flags_save_string = ndr->flags;
1534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1535                         if (r->parameters) {
1536                                 uint32_t _relative_save_offset;
1537                                 _relative_save_offset = ndr->offset;
1538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1539                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1540                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1543                                 ndr->offset = _relative_save_offset;
1544                         }
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 if (r->secdesc) {
1548                         uint32_t _relative_save_offset;
1549                         _relative_save_offset = ndr->offset;
1550                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1551                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1552                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1553                         {
1554                                 struct ndr_pull *_ndr_secdesc;
1555                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1556                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1557                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1558                         }
1559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1560                         ndr->offset = _relative_save_offset;
1561                 }
1562         }
1563         return NDR_ERR_SUCCESS;
1564 }
1565
1566 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1567 {
1568         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1569         ndr->depth++;
1570         ndr_print_ptr(ndr, "servername", r->servername);
1571         ndr->depth++;
1572         if (r->servername) {
1573                 ndr_print_string(ndr, "servername", r->servername);
1574         }
1575         ndr->depth--;
1576         ndr_print_ptr(ndr, "printername", r->printername);
1577         ndr->depth++;
1578         if (r->printername) {
1579                 ndr_print_string(ndr, "printername", r->printername);
1580         }
1581         ndr->depth--;
1582         ndr_print_ptr(ndr, "sharename", r->sharename);
1583         ndr->depth++;
1584         if (r->sharename) {
1585                 ndr_print_string(ndr, "sharename", r->sharename);
1586         }
1587         ndr->depth--;
1588         ndr_print_ptr(ndr, "portname", r->portname);
1589         ndr->depth++;
1590         if (r->portname) {
1591                 ndr_print_string(ndr, "portname", r->portname);
1592         }
1593         ndr->depth--;
1594         ndr_print_ptr(ndr, "drivername", r->drivername);
1595         ndr->depth++;
1596         if (r->drivername) {
1597                 ndr_print_string(ndr, "drivername", r->drivername);
1598         }
1599         ndr->depth--;
1600         ndr_print_ptr(ndr, "comment", r->comment);
1601         ndr->depth++;
1602         if (r->comment) {
1603                 ndr_print_string(ndr, "comment", r->comment);
1604         }
1605         ndr->depth--;
1606         ndr_print_ptr(ndr, "location", r->location);
1607         ndr->depth++;
1608         if (r->location) {
1609                 ndr_print_string(ndr, "location", r->location);
1610         }
1611         ndr->depth--;
1612         ndr_print_ptr(ndr, "devmode", r->devmode);
1613         ndr->depth++;
1614         if (r->devmode) {
1615                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1616         }
1617         ndr->depth--;
1618         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1619         ndr->depth++;
1620         if (r->sepfile) {
1621                 ndr_print_string(ndr, "sepfile", r->sepfile);
1622         }
1623         ndr->depth--;
1624         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1625         ndr->depth++;
1626         if (r->printprocessor) {
1627                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1628         }
1629         ndr->depth--;
1630         ndr_print_ptr(ndr, "datatype", r->datatype);
1631         ndr->depth++;
1632         if (r->datatype) {
1633                 ndr_print_string(ndr, "datatype", r->datatype);
1634         }
1635         ndr->depth--;
1636         ndr_print_ptr(ndr, "parameters", r->parameters);
1637         ndr->depth++;
1638         if (r->parameters) {
1639                 ndr_print_string(ndr, "parameters", r->parameters);
1640         }
1641         ndr->depth--;
1642         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1643         ndr->depth++;
1644         if (r->secdesc) {
1645                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1646         }
1647         ndr->depth--;
1648         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1649         ndr_print_uint32(ndr, "priority", r->priority);
1650         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1651         ndr_print_uint32(ndr, "starttime", r->starttime);
1652         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1653         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1654         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1655         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1656         ndr->depth--;
1657 }
1658
1659 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_push_align(ndr, 4));
1663                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1664         }
1665         if (ndr_flags & NDR_BUFFERS) {
1666                 if (r->secdesc) {
1667                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1668                         {
1669                                 struct ndr_push *_ndr_secdesc;
1670                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1671                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1672                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1673                         }
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1680 {
1681         uint32_t _ptr_secdesc;
1682         TALLOC_CTX *_mem_save_secdesc_0;
1683         if (ndr_flags & NDR_SCALARS) {
1684                 NDR_CHECK(ndr_pull_align(ndr, 4));
1685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1686                 if (_ptr_secdesc) {
1687                         NDR_PULL_ALLOC(ndr, r->secdesc);
1688                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1689                 } else {
1690                         r->secdesc = NULL;
1691                 }
1692         }
1693         if (ndr_flags & NDR_BUFFERS) {
1694                 if (r->secdesc) {
1695                         uint32_t _relative_save_offset;
1696                         _relative_save_offset = ndr->offset;
1697                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1698                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1700                         {
1701                                 struct ndr_pull *_ndr_secdesc;
1702                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1703                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1704                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1705                         }
1706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1707                         ndr->offset = _relative_save_offset;
1708                 }
1709         }
1710         return NDR_ERR_SUCCESS;
1711 }
1712
1713 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1714 {
1715         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1716         ndr->depth++;
1717         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1718         ndr->depth++;
1719         if (r->secdesc) {
1720                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1721         }
1722         ndr->depth--;
1723         ndr->depth--;
1724 }
1725
1726 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1727 {
1728         if (ndr_flags & NDR_SCALARS) {
1729                 NDR_CHECK(ndr_push_align(ndr, 4));
1730                 {
1731                         uint32_t _flags_save_string = ndr->flags;
1732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1733                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1734                         ndr->flags = _flags_save_string;
1735                 }
1736                 {
1737                         uint32_t _flags_save_string = ndr->flags;
1738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1740                         ndr->flags = _flags_save_string;
1741                 }
1742                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1743         }
1744         if (ndr_flags & NDR_BUFFERS) {
1745                 {
1746                         uint32_t _flags_save_string = ndr->flags;
1747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1748                         if (r->printername) {
1749                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1750                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1751                         }
1752                         ndr->flags = _flags_save_string;
1753                 }
1754                 {
1755                         uint32_t _flags_save_string = ndr->flags;
1756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1757                         if (r->servername) {
1758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1760                         }
1761                         ndr->flags = _flags_save_string;
1762                 }
1763         }
1764         return NDR_ERR_SUCCESS;
1765 }
1766
1767 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1768 {
1769         uint32_t _ptr_printername;
1770         TALLOC_CTX *_mem_save_printername_0;
1771         uint32_t _ptr_servername;
1772         TALLOC_CTX *_mem_save_servername_0;
1773         if (ndr_flags & NDR_SCALARS) {
1774                 NDR_CHECK(ndr_pull_align(ndr, 4));
1775                 {
1776                         uint32_t _flags_save_string = ndr->flags;
1777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1779                         if (_ptr_printername) {
1780                                 NDR_PULL_ALLOC(ndr, r->printername);
1781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1782                         } else {
1783                                 r->printername = NULL;
1784                         }
1785                         ndr->flags = _flags_save_string;
1786                 }
1787                 {
1788                         uint32_t _flags_save_string = ndr->flags;
1789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1791                         if (_ptr_servername) {
1792                                 NDR_PULL_ALLOC(ndr, r->servername);
1793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1794                         } else {
1795                                 r->servername = NULL;
1796                         }
1797                         ndr->flags = _flags_save_string;
1798                 }
1799                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1800         }
1801         if (ndr_flags & NDR_BUFFERS) {
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         if (r->printername) {
1806                                 uint32_t _relative_save_offset;
1807                                 _relative_save_offset = ndr->offset;
1808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1809                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1810                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1813                                 ndr->offset = _relative_save_offset;
1814                         }
1815                         ndr->flags = _flags_save_string;
1816                 }
1817                 {
1818                         uint32_t _flags_save_string = ndr->flags;
1819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1820                         if (r->servername) {
1821                                 uint32_t _relative_save_offset;
1822                                 _relative_save_offset = ndr->offset;
1823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1824                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1825                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1828                                 ndr->offset = _relative_save_offset;
1829                         }
1830                         ndr->flags = _flags_save_string;
1831                 }
1832         }
1833         return NDR_ERR_SUCCESS;
1834 }
1835
1836 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1837 {
1838         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1839         ndr->depth++;
1840         ndr_print_ptr(ndr, "printername", r->printername);
1841         ndr->depth++;
1842         if (r->printername) {
1843                 ndr_print_string(ndr, "printername", r->printername);
1844         }
1845         ndr->depth--;
1846         ndr_print_ptr(ndr, "servername", r->servername);
1847         ndr->depth++;
1848         if (r->servername) {
1849                 ndr_print_string(ndr, "servername", r->servername);
1850         }
1851         ndr->depth--;
1852         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1853         ndr->depth--;
1854 }
1855
1856 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1857 {
1858         if (ndr_flags & NDR_SCALARS) {
1859                 NDR_CHECK(ndr_push_align(ndr, 4));
1860                 {
1861                         uint32_t _flags_save_string = ndr->flags;
1862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1864                         ndr->flags = _flags_save_string;
1865                 }
1866                 {
1867                         uint32_t _flags_save_string = ndr->flags;
1868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1870                         ndr->flags = _flags_save_string;
1871                 }
1872                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1875         }
1876         if (ndr_flags & NDR_BUFFERS) {
1877                 {
1878                         uint32_t _flags_save_string = ndr->flags;
1879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1880                         if (r->printername) {
1881                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         if (r->portname) {
1890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1892                         }
1893                         ndr->flags = _flags_save_string;
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1900 {
1901         uint32_t _ptr_printername;
1902         TALLOC_CTX *_mem_save_printername_0;
1903         uint32_t _ptr_portname;
1904         TALLOC_CTX *_mem_save_portname_0;
1905         if (ndr_flags & NDR_SCALARS) {
1906                 NDR_CHECK(ndr_pull_align(ndr, 4));
1907                 {
1908                         uint32_t _flags_save_string = ndr->flags;
1909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1911                         if (_ptr_printername) {
1912                                 NDR_PULL_ALLOC(ndr, r->printername);
1913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1914                         } else {
1915                                 r->printername = NULL;
1916                         }
1917                         ndr->flags = _flags_save_string;
1918                 }
1919                 {
1920                         uint32_t _flags_save_string = ndr->flags;
1921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1923                         if (_ptr_portname) {
1924                                 NDR_PULL_ALLOC(ndr, r->portname);
1925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1926                         } else {
1927                                 r->portname = NULL;
1928                         }
1929                         ndr->flags = _flags_save_string;
1930                 }
1931                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1934         }
1935         if (ndr_flags & NDR_BUFFERS) {
1936                 {
1937                         uint32_t _flags_save_string = ndr->flags;
1938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1939                         if (r->printername) {
1940                                 uint32_t _relative_save_offset;
1941                                 _relative_save_offset = ndr->offset;
1942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1943                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1944                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1947                                 ndr->offset = _relative_save_offset;
1948                         }
1949                         ndr->flags = _flags_save_string;
1950                 }
1951                 {
1952                         uint32_t _flags_save_string = ndr->flags;
1953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1954                         if (r->portname) {
1955                                 uint32_t _relative_save_offset;
1956                                 _relative_save_offset = ndr->offset;
1957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1958                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966         }
1967         return NDR_ERR_SUCCESS;
1968 }
1969
1970 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1971 {
1972         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1973         ndr->depth++;
1974         ndr_print_ptr(ndr, "printername", r->printername);
1975         ndr->depth++;
1976         if (r->printername) {
1977                 ndr_print_string(ndr, "printername", r->printername);
1978         }
1979         ndr->depth--;
1980         ndr_print_ptr(ndr, "portname", r->portname);
1981         ndr->depth++;
1982         if (r->portname) {
1983                 ndr_print_string(ndr, "portname", r->portname);
1984         }
1985         ndr->depth--;
1986         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1987         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1988         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1989         ndr->depth--;
1990 }
1991
1992 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1993 {
1994         if (ndr_flags & NDR_SCALARS) {
1995                 NDR_CHECK(ndr_push_align(ndr, 4));
1996                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1997         }
1998         if (ndr_flags & NDR_BUFFERS) {
1999         }
2000         return NDR_ERR_SUCCESS;
2001 }
2002
2003 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2004 {
2005         if (ndr_flags & NDR_SCALARS) {
2006                 NDR_CHECK(ndr_pull_align(ndr, 4));
2007                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2008         }
2009         if (ndr_flags & NDR_BUFFERS) {
2010         }
2011         return NDR_ERR_SUCCESS;
2012 }
2013
2014 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2015 {
2016         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2017         ndr->depth++;
2018         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2019         ndr->depth--;
2020 }
2021
2022 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2023 {
2024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2025         return NDR_ERR_SUCCESS;
2026 }
2027
2028 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2029 {
2030         uint32_t v;
2031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2032         *r = v;
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2037 {
2038         ndr_print_uint32(ndr, name, r);
2039         ndr->depth++;
2040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2045         ndr->depth--;
2046 }
2047
2048 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2049 {
2050         if (ndr_flags & NDR_SCALARS) {
2051                 NDR_CHECK(ndr_push_align(ndr, 4));
2052                 {
2053                         uint32_t _flags_save_string = ndr->flags;
2054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2067                         }
2068                         ndr->flags = _flags_save_string;
2069                 }
2070         }
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2075 {
2076         uint32_t _ptr_guid;
2077         TALLOC_CTX *_mem_save_guid_0;
2078         if (ndr_flags & NDR_SCALARS) {
2079                 NDR_CHECK(ndr_pull_align(ndr, 4));
2080                 {
2081                         uint32_t _flags_save_string = ndr->flags;
2082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2084                         if (_ptr_guid) {
2085                                 NDR_PULL_ALLOC(ndr, r->guid);
2086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2087                         } else {
2088                                 r->guid = NULL;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2093         }
2094         if (ndr_flags & NDR_BUFFERS) {
2095                 {
2096                         uint32_t _flags_save_string = ndr->flags;
2097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2098                         if (r->guid) {
2099                                 uint32_t _relative_save_offset;
2100                                 _relative_save_offset = ndr->offset;
2101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2102                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2103                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "guid", r->guid);
2119         ndr->depth++;
2120         if (r->guid) {
2121                 ndr_print_string(ndr, "guid", r->guid);
2122         }
2123         ndr->depth--;
2124         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2125         ndr->depth--;
2126 }
2127
2128 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_push_align(ndr, 4));
2132                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 if (r->devmode) {
2136                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2137                         {
2138                                 struct ndr_push *_ndr_devmode;
2139                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2140                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2141                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2142                         }
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2149 {
2150         uint32_t _ptr_devmode;
2151         TALLOC_CTX *_mem_save_devmode_0;
2152         if (ndr_flags & NDR_SCALARS) {
2153                 NDR_CHECK(ndr_pull_align(ndr, 4));
2154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2155                 if (_ptr_devmode) {
2156                         NDR_PULL_ALLOC(ndr, r->devmode);
2157                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2158                 } else {
2159                         r->devmode = NULL;
2160                 }
2161         }
2162         if (ndr_flags & NDR_BUFFERS) {
2163                 if (r->devmode) {
2164                         uint32_t _relative_save_offset;
2165                         _relative_save_offset = ndr->offset;
2166                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2167                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2168                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2169                         {
2170                                 struct ndr_pull *_ndr_devmode;
2171                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2172                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2173                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2174                         }
2175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2176                         ndr->offset = _relative_save_offset;
2177                 }
2178         }
2179         return NDR_ERR_SUCCESS;
2180 }
2181
2182 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2183 {
2184         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2185         ndr->depth++;
2186         ndr_print_ptr(ndr, "devmode", r->devmode);
2187         ndr->depth++;
2188         if (r->devmode) {
2189                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2190         }
2191         ndr->depth--;
2192         ndr->depth--;
2193 }
2194
2195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2196 {
2197         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2198         if (ndr_flags & NDR_SCALARS) {
2199                 int level = ndr_push_get_switch_value(ndr, r);
2200                 switch (level) {
2201                         case 0: {
2202                                 NDR_CHECK(ndr_push_align(ndr, 4));
2203                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2204                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2205                         break; }
2206
2207                         case 1: {
2208                                 NDR_CHECK(ndr_push_align(ndr, 4));
2209                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2210                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2211                         break; }
2212
2213                         case 2: {
2214                                 NDR_CHECK(ndr_push_align(ndr, 4));
2215                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2216                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2217                         break; }
2218
2219                         case 3: {
2220                                 NDR_CHECK(ndr_push_align(ndr, 4));
2221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2222                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2223                         break; }
2224
2225                         case 4: {
2226                                 NDR_CHECK(ndr_push_align(ndr, 4));
2227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2228                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2229                         break; }
2230
2231                         case 5: {
2232                                 NDR_CHECK(ndr_push_align(ndr, 4));
2233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2234                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2235                         break; }
2236
2237                         case 6: {
2238                                 NDR_CHECK(ndr_push_align(ndr, 4));
2239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2240                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2241                         break; }
2242
2243                         case 7: {
2244                                 NDR_CHECK(ndr_push_align(ndr, 4));
2245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2246                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2247                         break; }
2248
2249                         case 8: {
2250                                 NDR_CHECK(ndr_push_align(ndr, 4));
2251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2252                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2253                         break; }
2254
2255                         case 9: {
2256                                 NDR_CHECK(ndr_push_align(ndr, 4));
2257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2258                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2259                         break; }
2260
2261                         default: {
2262                         break; }
2263
2264                 }
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 int level = ndr_push_get_switch_value(ndr, r);
2268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2269                 switch (level) {
2270                         case 0:
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2272                         break;
2273
2274                         case 1:
2275                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2276                         break;
2277
2278                         case 2:
2279                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2280                         break;
2281
2282                         case 3:
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2284                         break;
2285
2286                         case 4:
2287                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2288                         break;
2289
2290                         case 5:
2291                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2292                         break;
2293
2294                         case 6:
2295                         break;
2296
2297                         case 7:
2298                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2299                         break;
2300
2301                         case 8:
2302                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2303                         break;
2304
2305                         case 9:
2306                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2307                         break;
2308
2309                         default:
2310                         break;
2311
2312                 }
2313         }
2314         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2319 {
2320         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2321         int level;
2322         level = ndr_pull_get_switch_value(ndr, r);
2323         if (ndr_flags & NDR_SCALARS) {
2324                 switch (level) {
2325                         case 0: {
2326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2328                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2329                         break; }
2330
2331                         case 1: {
2332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2334                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2335                         break; }
2336
2337                         case 2: {
2338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2340                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2341                         break; }
2342
2343                         case 3: {
2344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2346                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2347                         break; }
2348
2349                         case 4: {
2350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2352                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2353                         break; }
2354
2355                         case 5: {
2356                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2357                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2358                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2359                         break; }
2360
2361                         case 6: {
2362                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2365                         break; }
2366
2367                         case 7: {
2368                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2369                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2370                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2371                         break; }
2372
2373                         case 8: {
2374                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2375                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2376                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2377                         break; }
2378
2379                         case 9: {
2380                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2381                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2382                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2383                         break; }
2384
2385                         default: {
2386                         break; }
2387
2388                 }
2389         }
2390         if (ndr_flags & NDR_BUFFERS) {
2391                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2392                 switch (level) {
2393                         case 0:
2394                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2395                         break;
2396
2397                         case 1:
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2399                         break;
2400
2401                         case 2:
2402                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2403                         break;
2404
2405                         case 3:
2406                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2407                         break;
2408
2409                         case 4:
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2411                         break;
2412
2413                         case 5:
2414                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2415                         break;
2416
2417                         case 6:
2418                         break;
2419
2420                         case 7:
2421                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2422                         break;
2423
2424                         case 8:
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2426                         break;
2427
2428                         case 9:
2429                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2430                         break;
2431
2432                         default:
2433                         break;
2434
2435                 }
2436         }
2437         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2438         return NDR_ERR_SUCCESS;
2439 }
2440
2441 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2442 {
2443         int level;
2444         level = ndr_print_get_switch_value(ndr, r);
2445         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2446         switch (level) {
2447                 case 0:
2448                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2449                 break;
2450
2451                 case 1:
2452                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2453                 break;
2454
2455                 case 2:
2456                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2457                 break;
2458
2459                 case 3:
2460                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2461                 break;
2462
2463                 case 4:
2464                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2465                 break;
2466
2467                 case 5:
2468                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2469                 break;
2470
2471                 case 6:
2472                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2473                 break;
2474
2475                 case 7:
2476                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2477                 break;
2478
2479                 case 8:
2480                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2481                 break;
2482
2483                 case 9:
2484                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2485                 break;
2486
2487                 default:
2488                 break;
2489
2490         }
2491 }
2492
2493 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2494 {
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 4));
2497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 if (r->devmode) {
2502                         {
2503                                 struct ndr_push *_ndr_devmode;
2504                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2505                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2506                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2507                         }
2508                 }
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2514 {
2515         uint32_t _ptr_devmode;
2516         TALLOC_CTX *_mem_save_devmode_0;
2517         if (ndr_flags & NDR_SCALARS) {
2518                 NDR_CHECK(ndr_pull_align(ndr, 4));
2519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2521                 if (_ptr_devmode) {
2522                         NDR_PULL_ALLOC(ndr, r->devmode);
2523                 } else {
2524                         r->devmode = NULL;
2525                 }
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 if (r->devmode) {
2529                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2530                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2531                         {
2532                                 struct ndr_pull *_ndr_devmode;
2533                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2534                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2535                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2536                         }
2537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2538                 }
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2544 {
2545         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2546         ndr->depth++;
2547         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);
2548         ndr_print_ptr(ndr, "devmode", r->devmode);
2549         ndr->depth++;
2550         if (r->devmode) {
2551                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2552         }
2553         ndr->depth--;
2554         ndr->depth--;
2555 }
2556
2557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2558 {
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_align(ndr, 4));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2562                 {
2563                         uint32_t _flags_save_string = ndr->flags;
2564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2566                         ndr->flags = _flags_save_string;
2567                 }
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2572                         ndr->flags = _flags_save_string;
2573                 }
2574                 {
2575                         uint32_t _flags_save_string = ndr->flags;
2576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2578                         ndr->flags = _flags_save_string;
2579                 }
2580                 {
2581                         uint32_t _flags_save_string = ndr->flags;
2582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2584                         ndr->flags = _flags_save_string;
2585                 }
2586                 {
2587                         uint32_t _flags_save_string = ndr->flags;
2588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2590                         ndr->flags = _flags_save_string;
2591                 }
2592                 {
2593                         uint32_t _flags_save_string = ndr->flags;
2594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2596                         ndr->flags = _flags_save_string;
2597                 }
2598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2604         }
2605         if (ndr_flags & NDR_BUFFERS) {
2606                 {
2607                         uint32_t _flags_save_string = ndr->flags;
2608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2609                         if (r->printer_name) {
2610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->server_name) {
2619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2621                         }
2622                         ndr->flags = _flags_save_string;
2623                 }
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->user_name) {
2628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633                 {
2634                         uint32_t _flags_save_string = ndr->flags;
2635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2636                         if (r->document_name) {
2637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2639                         }
2640                         ndr->flags = _flags_save_string;
2641                 }
2642                 {
2643                         uint32_t _flags_save_string = ndr->flags;
2644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2645                         if (r->data_type) {
2646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->text_status) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660         }
2661         return NDR_ERR_SUCCESS;
2662 }
2663
2664 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2665 {
2666         uint32_t _ptr_printer_name;
2667         TALLOC_CTX *_mem_save_printer_name_0;
2668         uint32_t _ptr_server_name;
2669         TALLOC_CTX *_mem_save_server_name_0;
2670         uint32_t _ptr_user_name;
2671         TALLOC_CTX *_mem_save_user_name_0;
2672         uint32_t _ptr_document_name;
2673         TALLOC_CTX *_mem_save_document_name_0;
2674         uint32_t _ptr_data_type;
2675         TALLOC_CTX *_mem_save_data_type_0;
2676         uint32_t _ptr_text_status;
2677         TALLOC_CTX *_mem_save_text_status_0;
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2685                         if (_ptr_printer_name) {
2686                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2688                         } else {
2689                                 r->printer_name = NULL;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2697                         if (_ptr_server_name) {
2698                                 NDR_PULL_ALLOC(ndr, r->server_name);
2699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2700                         } else {
2701                                 r->server_name = NULL;
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705                 {
2706                         uint32_t _flags_save_string = ndr->flags;
2707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2709                         if (_ptr_user_name) {
2710                                 NDR_PULL_ALLOC(ndr, r->user_name);
2711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2712                         } else {
2713                                 r->user_name = NULL;
2714                         }
2715                         ndr->flags = _flags_save_string;
2716                 }
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2721                         if (_ptr_document_name) {
2722                                 NDR_PULL_ALLOC(ndr, r->document_name);
2723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2724                         } else {
2725                                 r->document_name = NULL;
2726                         }
2727                         ndr->flags = _flags_save_string;
2728                 }
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2733                         if (_ptr_data_type) {
2734                                 NDR_PULL_ALLOC(ndr, r->data_type);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2736                         } else {
2737                                 r->data_type = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2745                         if (_ptr_text_status) {
2746                                 NDR_PULL_ALLOC(ndr, r->text_status);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2748                         } else {
2749                                 r->text_status = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2758                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2759         }
2760         if (ndr_flags & NDR_BUFFERS) {
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         if (r->printer_name) {
2765                                 uint32_t _relative_save_offset;
2766                                 _relative_save_offset = ndr->offset;
2767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2768                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2769                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2772                                 ndr->offset = _relative_save_offset;
2773                         }
2774                         ndr->flags = _flags_save_string;
2775                 }
2776                 {
2777                         uint32_t _flags_save_string = ndr->flags;
2778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2779                         if (r->server_name) {
2780                                 uint32_t _relative_save_offset;
2781                                 _relative_save_offset = ndr->offset;
2782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2783                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2787                                 ndr->offset = _relative_save_offset;
2788                         }
2789                         ndr->flags = _flags_save_string;
2790                 }
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         if (r->user_name) {
2795                                 uint32_t _relative_save_offset;
2796                                 _relative_save_offset = ndr->offset;
2797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2798                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2802                                 ndr->offset = _relative_save_offset;
2803                         }
2804                         ndr->flags = _flags_save_string;
2805                 }
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->document_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2813                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2817                                 ndr->offset = _relative_save_offset;
2818                         }
2819                         ndr->flags = _flags_save_string;
2820                 }
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         if (r->data_type) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2828                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2832                                 ndr->offset = _relative_save_offset;
2833                         }
2834                         ndr->flags = _flags_save_string;
2835                 }
2836                 {
2837                         uint32_t _flags_save_string = ndr->flags;
2838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2839                         if (r->text_status) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2843                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851         }
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2856 {
2857         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2858         ndr->depth++;
2859         ndr_print_uint32(ndr, "job_id", r->job_id);
2860         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2861         ndr->depth++;
2862         if (r->printer_name) {
2863                 ndr_print_string(ndr, "printer_name", r->printer_name);
2864         }
2865         ndr->depth--;
2866         ndr_print_ptr(ndr, "server_name", r->server_name);
2867         ndr->depth++;
2868         if (r->server_name) {
2869                 ndr_print_string(ndr, "server_name", r->server_name);
2870         }
2871         ndr->depth--;
2872         ndr_print_ptr(ndr, "user_name", r->user_name);
2873         ndr->depth++;
2874         if (r->user_name) {
2875                 ndr_print_string(ndr, "user_name", r->user_name);
2876         }
2877         ndr->depth--;
2878         ndr_print_ptr(ndr, "document_name", r->document_name);
2879         ndr->depth++;
2880         if (r->document_name) {
2881                 ndr_print_string(ndr, "document_name", r->document_name);
2882         }
2883         ndr->depth--;
2884         ndr_print_ptr(ndr, "data_type", r->data_type);
2885         ndr->depth++;
2886         if (r->data_type) {
2887                 ndr_print_string(ndr, "data_type", r->data_type);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "text_status", r->text_status);
2891         ndr->depth++;
2892         if (r->text_status) {
2893                 ndr_print_string(ndr, "text_status", r->text_status);
2894         }
2895         ndr->depth--;
2896         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2897         ndr_print_uint32(ndr, "priority", r->priority);
2898         ndr_print_uint32(ndr, "position", r->position);
2899         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2900         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2901         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2902         ndr->depth--;
2903 }
2904
2905 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2906 {
2907         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2908 }
2909
2910 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2911 {
2912         if (ndr_flags & NDR_SCALARS) {
2913                 NDR_CHECK(ndr_push_align(ndr, 4));
2914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2915                 {
2916                         uint32_t _flags_save_string = ndr->flags;
2917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2918                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2919                         ndr->flags = _flags_save_string;
2920                 }
2921                 {
2922                         uint32_t _flags_save_string = ndr->flags;
2923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2924                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2925                         ndr->flags = _flags_save_string;
2926                 }
2927                 {
2928                         uint32_t _flags_save_string = ndr->flags;
2929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2930                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2931                         ndr->flags = _flags_save_string;
2932                 }
2933                 {
2934                         uint32_t _flags_save_string = ndr->flags;
2935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2936                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2937                         ndr->flags = _flags_save_string;
2938                 }
2939                 {
2940                         uint32_t _flags_save_string = ndr->flags;
2941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2942                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2943                         ndr->flags = _flags_save_string;
2944                 }
2945                 {
2946                         uint32_t _flags_save_string = ndr->flags;
2947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2949                         ndr->flags = _flags_save_string;
2950                 }
2951                 {
2952                         uint32_t _flags_save_string = ndr->flags;
2953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2954                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
2955                         ndr->flags = _flags_save_string;
2956                 }
2957                 {
2958                         uint32_t _flags_save_string = ndr->flags;
2959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2960                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
2961                         ndr->flags = _flags_save_string;
2962                 }
2963                 {
2964                         uint32_t _flags_save_string = ndr->flags;
2965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2966                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
2967                         ndr->flags = _flags_save_string;
2968                 }
2969                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2970                 {
2971                         uint32_t _flags_save_string = ndr->flags;
2972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2973                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2974                         ndr->flags = _flags_save_string;
2975                 }
2976                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2977                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
2982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2984                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2987         }
2988         if (ndr_flags & NDR_BUFFERS) {
2989                 {
2990                         uint32_t _flags_save_string = ndr->flags;
2991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2992                         if (r->printer_name) {
2993                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2994                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2995                         }
2996                         ndr->flags = _flags_save_string;
2997                 }
2998                 {
2999                         uint32_t _flags_save_string = ndr->flags;
3000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3001                         if (r->server_name) {
3002                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3003                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3004                         }
3005                         ndr->flags = _flags_save_string;
3006                 }
3007                 {
3008                         uint32_t _flags_save_string = ndr->flags;
3009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3010                         if (r->user_name) {
3011                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3012                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3013                         }
3014                         ndr->flags = _flags_save_string;
3015                 }
3016                 {
3017                         uint32_t _flags_save_string = ndr->flags;
3018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3019                         if (r->document_name) {
3020                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3021                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3022                         }
3023                         ndr->flags = _flags_save_string;
3024                 }
3025                 {
3026                         uint32_t _flags_save_string = ndr->flags;
3027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3028                         if (r->notify_name) {
3029                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3030                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3031                         }
3032                         ndr->flags = _flags_save_string;
3033                 }
3034                 {
3035                         uint32_t _flags_save_string = ndr->flags;
3036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3037                         if (r->data_type) {
3038                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3039                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3040                         }
3041                         ndr->flags = _flags_save_string;
3042                 }
3043                 {
3044                         uint32_t _flags_save_string = ndr->flags;
3045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3046                         if (r->print_processor) {
3047                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3048                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3049                         }
3050                         ndr->flags = _flags_save_string;
3051                 }
3052                 {
3053                         uint32_t _flags_save_string = ndr->flags;
3054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3055                         if (r->parameters) {
3056                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3057                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3058                         }
3059                         ndr->flags = _flags_save_string;
3060                 }
3061                 {
3062                         uint32_t _flags_save_string = ndr->flags;
3063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3064                         if (r->driver_name) {
3065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3067                         }
3068                         ndr->flags = _flags_save_string;
3069                 }
3070                 if (r->devmode) {
3071                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3072                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3073                 }
3074                 {
3075                         uint32_t _flags_save_string = ndr->flags;
3076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3077                         if (r->text_status) {
3078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3080                         }
3081                         ndr->flags = _flags_save_string;
3082                 }
3083                 if (r->secdesc) {
3084                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3085                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3086                 }
3087         }
3088         return NDR_ERR_SUCCESS;
3089 }
3090
3091 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3092 {
3093         uint32_t _ptr_printer_name;
3094         TALLOC_CTX *_mem_save_printer_name_0;
3095         uint32_t _ptr_server_name;
3096         TALLOC_CTX *_mem_save_server_name_0;
3097         uint32_t _ptr_user_name;
3098         TALLOC_CTX *_mem_save_user_name_0;
3099         uint32_t _ptr_document_name;
3100         TALLOC_CTX *_mem_save_document_name_0;
3101         uint32_t _ptr_notify_name;
3102         TALLOC_CTX *_mem_save_notify_name_0;
3103         uint32_t _ptr_data_type;
3104         TALLOC_CTX *_mem_save_data_type_0;
3105         uint32_t _ptr_print_processor;
3106         TALLOC_CTX *_mem_save_print_processor_0;
3107         uint32_t _ptr_parameters;
3108         TALLOC_CTX *_mem_save_parameters_0;
3109         uint32_t _ptr_driver_name;
3110         TALLOC_CTX *_mem_save_driver_name_0;
3111         uint32_t _ptr_devmode;
3112         TALLOC_CTX *_mem_save_devmode_0;
3113         uint32_t _ptr_text_status;
3114         TALLOC_CTX *_mem_save_text_status_0;
3115         uint32_t _ptr_secdesc;
3116         TALLOC_CTX *_mem_save_secdesc_0;
3117         if (ndr_flags & NDR_SCALARS) {
3118                 NDR_CHECK(ndr_pull_align(ndr, 4));
3119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3120                 {
3121                         uint32_t _flags_save_string = ndr->flags;
3122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3123                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3124                         if (_ptr_printer_name) {
3125                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3126                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3127                         } else {
3128                                 r->printer_name = NULL;
3129                         }
3130                         ndr->flags = _flags_save_string;
3131                 }
3132                 {
3133                         uint32_t _flags_save_string = ndr->flags;
3134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3135                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3136                         if (_ptr_server_name) {
3137                                 NDR_PULL_ALLOC(ndr, r->server_name);
3138                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3139                         } else {
3140                                 r->server_name = NULL;
3141                         }
3142                         ndr->flags = _flags_save_string;
3143                 }
3144                 {
3145                         uint32_t _flags_save_string = ndr->flags;
3146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3147                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3148                         if (_ptr_user_name) {
3149                                 NDR_PULL_ALLOC(ndr, r->user_name);
3150                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3151                         } else {
3152                                 r->user_name = NULL;
3153                         }
3154                         ndr->flags = _flags_save_string;
3155                 }
3156                 {
3157                         uint32_t _flags_save_string = ndr->flags;
3158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3159                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3160                         if (_ptr_document_name) {
3161                                 NDR_PULL_ALLOC(ndr, r->document_name);
3162                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3163                         } else {
3164                                 r->document_name = NULL;
3165                         }
3166                         ndr->flags = _flags_save_string;
3167                 }
3168                 {
3169                         uint32_t _flags_save_string = ndr->flags;
3170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3171                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3172                         if (_ptr_notify_name) {
3173                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3174                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3175                         } else {
3176                                 r->notify_name = NULL;
3177                         }
3178                         ndr->flags = _flags_save_string;
3179                 }
3180                 {
3181                         uint32_t _flags_save_string = ndr->flags;
3182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3183                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3184                         if (_ptr_data_type) {
3185                                 NDR_PULL_ALLOC(ndr, r->data_type);
3186                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3187                         } else {
3188                                 r->data_type = NULL;
3189                         }
3190                         ndr->flags = _flags_save_string;
3191                 }
3192                 {
3193                         uint32_t _flags_save_string = ndr->flags;
3194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3196                         if (_ptr_print_processor) {
3197                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3199                         } else {
3200                                 r->print_processor = NULL;
3201                         }
3202                         ndr->flags = _flags_save_string;
3203                 }
3204                 {
3205                         uint32_t _flags_save_string = ndr->flags;
3206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3208                         if (_ptr_parameters) {
3209                                 NDR_PULL_ALLOC(ndr, r->parameters);
3210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3211                         } else {
3212                                 r->parameters = NULL;
3213                         }
3214                         ndr->flags = _flags_save_string;
3215                 }
3216                 {
3217                         uint32_t _flags_save_string = ndr->flags;
3218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3220                         if (_ptr_driver_name) {
3221                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3223                         } else {
3224                                 r->driver_name = NULL;
3225                         }
3226                         ndr->flags = _flags_save_string;
3227                 }
3228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3229                 if (_ptr_devmode) {
3230                         NDR_PULL_ALLOC(ndr, r->devmode);
3231                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3232                 } else {
3233                         r->devmode = NULL;
3234                 }
3235                 {
3236                         uint32_t _flags_save_string = ndr->flags;
3237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3239                         if (_ptr_text_status) {
3240                                 NDR_PULL_ALLOC(ndr, r->text_status);
3241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3242                         } else {
3243                                 r->text_status = NULL;
3244                         }
3245                         ndr->flags = _flags_save_string;
3246                 }
3247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3248                 if (_ptr_secdesc) {
3249                         NDR_PULL_ALLOC(ndr, r->secdesc);
3250                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3251                 } else {
3252                         r->secdesc = NULL;
3253                 }
3254                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3261                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3264         }
3265         if (ndr_flags & NDR_BUFFERS) {
3266                 {
3267                         uint32_t _flags_save_string = ndr->flags;
3268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3269                         if (r->printer_name) {
3270                                 uint32_t _relative_save_offset;
3271                                 _relative_save_offset = ndr->offset;
3272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3273                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3274                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3277                                 ndr->offset = _relative_save_offset;
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281                 {
3282                         uint32_t _flags_save_string = ndr->flags;
3283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3284                         if (r->server_name) {
3285                                 uint32_t _relative_save_offset;
3286                                 _relative_save_offset = ndr->offset;
3287                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3288                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3289                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3290                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3291                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3292                                 ndr->offset = _relative_save_offset;
3293                         }
3294                         ndr->flags = _flags_save_string;
3295                 }
3296                 {
3297                         uint32_t _flags_save_string = ndr->flags;
3298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3299                         if (r->user_name) {
3300                                 uint32_t _relative_save_offset;
3301                                 _relative_save_offset = ndr->offset;
3302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3303                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3304                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3307                                 ndr->offset = _relative_save_offset;
3308                         }
3309                         ndr->flags = _flags_save_string;
3310                 }
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->document_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3318                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3322                                 ndr->offset = _relative_save_offset;
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                         if (r->notify_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3333                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3337                                 ndr->offset = _relative_save_offset;
3338                         }
3339                         ndr->flags = _flags_save_string;
3340                 }
3341                 {
3342                         uint32_t _flags_save_string = ndr->flags;
3343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3344                         if (r->data_type) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3348                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3352                                 ndr->offset = _relative_save_offset;
3353                         }
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3359                         if (r->print_processor) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3363                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3367                                 ndr->offset = _relative_save_offset;
3368                         }
3369                         ndr->flags = _flags_save_string;
3370                 }
3371                 {
3372                         uint32_t _flags_save_string = ndr->flags;
3373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3374                         if (r->parameters) {
3375                                 uint32_t _relative_save_offset;
3376                                 _relative_save_offset = ndr->offset;
3377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3378                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3379                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3382                                 ndr->offset = _relative_save_offset;
3383                         }
3384                         ndr->flags = _flags_save_string;
3385                 }
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->driver_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3393                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3397                                 ndr->offset = _relative_save_offset;
3398                         }
3399                         ndr->flags = _flags_save_string;
3400                 }
3401                 if (r->devmode) {
3402                         uint32_t _relative_save_offset;
3403                         _relative_save_offset = ndr->offset;
3404                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3405                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3406                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3407                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3409                         ndr->offset = _relative_save_offset;
3410                 }
3411                 {
3412                         uint32_t _flags_save_string = ndr->flags;
3413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3414                         if (r->text_status) {
3415                                 uint32_t _relative_save_offset;
3416                                 _relative_save_offset = ndr->offset;
3417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3418                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3419                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3422                                 ndr->offset = _relative_save_offset;
3423                         }
3424                         ndr->flags = _flags_save_string;
3425                 }
3426                 if (r->secdesc) {
3427                         uint32_t _relative_save_offset;
3428                         _relative_save_offset = ndr->offset;
3429                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3430                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3431                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3432                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3434                         ndr->offset = _relative_save_offset;
3435                 }
3436         }
3437         return NDR_ERR_SUCCESS;
3438 }
3439
3440 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3441 {
3442         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3443         ndr->depth++;
3444         ndr_print_uint32(ndr, "job_id", r->job_id);
3445         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3446         ndr->depth++;
3447         if (r->printer_name) {
3448                 ndr_print_string(ndr, "printer_name", r->printer_name);
3449         }
3450         ndr->depth--;
3451         ndr_print_ptr(ndr, "server_name", r->server_name);
3452         ndr->depth++;
3453         if (r->server_name) {
3454                 ndr_print_string(ndr, "server_name", r->server_name);
3455         }
3456         ndr->depth--;
3457         ndr_print_ptr(ndr, "user_name", r->user_name);
3458         ndr->depth++;
3459         if (r->user_name) {
3460                 ndr_print_string(ndr, "user_name", r->user_name);
3461         }
3462         ndr->depth--;
3463         ndr_print_ptr(ndr, "document_name", r->document_name);
3464         ndr->depth++;
3465         if (r->document_name) {
3466                 ndr_print_string(ndr, "document_name", r->document_name);
3467         }
3468         ndr->depth--;
3469         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3470         ndr->depth++;
3471         if (r->notify_name) {
3472                 ndr_print_string(ndr, "notify_name", r->notify_name);
3473         }
3474         ndr->depth--;
3475         ndr_print_ptr(ndr, "data_type", r->data_type);
3476         ndr->depth++;
3477         if (r->data_type) {
3478                 ndr_print_string(ndr, "data_type", r->data_type);
3479         }
3480         ndr->depth--;
3481         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3482         ndr->depth++;
3483         if (r->print_processor) {
3484                 ndr_print_string(ndr, "print_processor", r->print_processor);
3485         }
3486         ndr->depth--;
3487         ndr_print_ptr(ndr, "parameters", r->parameters);
3488         ndr->depth++;
3489         if (r->parameters) {
3490                 ndr_print_string(ndr, "parameters", r->parameters);
3491         }
3492         ndr->depth--;
3493         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3494         ndr->depth++;
3495         if (r->driver_name) {
3496                 ndr_print_string(ndr, "driver_name", r->driver_name);
3497         }
3498         ndr->depth--;
3499         ndr_print_ptr(ndr, "devmode", r->devmode);
3500         ndr->depth++;
3501         if (r->devmode) {
3502                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3503         }
3504         ndr->depth--;
3505         ndr_print_ptr(ndr, "text_status", r->text_status);
3506         ndr->depth++;
3507         if (r->text_status) {
3508                 ndr_print_string(ndr, "text_status", r->text_status);
3509         }
3510         ndr->depth--;
3511         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3512         ndr->depth++;
3513         if (r->secdesc) {
3514                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3515         }
3516         ndr->depth--;
3517         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3518         ndr_print_uint32(ndr, "priority", r->priority);
3519         ndr_print_uint32(ndr, "position", r->position);
3520         ndr_print_uint32(ndr, "start_time", r->start_time);
3521         ndr_print_uint32(ndr, "until_time", r->until_time);
3522         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3523         ndr_print_uint32(ndr, "size", r->size);
3524         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3525         ndr_print_uint32(ndr, "time", r->time);
3526         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3527         ndr->depth--;
3528 }
3529
3530 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3531 {
3532         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3533 }
3534
3535 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3536 {
3537         if (ndr_flags & NDR_SCALARS) {
3538                 NDR_CHECK(ndr_push_align(ndr, 4));
3539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3542         }
3543         if (ndr_flags & NDR_BUFFERS) {
3544         }
3545         return NDR_ERR_SUCCESS;
3546 }
3547
3548 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3549 {
3550         if (ndr_flags & NDR_SCALARS) {
3551                 NDR_CHECK(ndr_pull_align(ndr, 4));
3552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3555         }
3556         if (ndr_flags & NDR_BUFFERS) {
3557         }
3558         return NDR_ERR_SUCCESS;
3559 }
3560
3561 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3562 {
3563         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3564         ndr->depth++;
3565         ndr_print_uint32(ndr, "job_id", r->job_id);
3566         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3567         ndr_print_uint32(ndr, "reserved", r->reserved);
3568         ndr->depth--;
3569 }
3570
3571 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3572 {
3573         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3574 }
3575
3576 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3577 {
3578         if (ndr_flags & NDR_SCALARS) {
3579                 NDR_CHECK(ndr_push_align(ndr, 4));
3580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3581                 {
3582                         uint32_t _flags_save_string = ndr->flags;
3583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3584                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3585                         ndr->flags = _flags_save_string;
3586                 }
3587                 {
3588                         uint32_t _flags_save_string = ndr->flags;
3589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3590                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3591                         ndr->flags = _flags_save_string;
3592                 }
3593                 {
3594                         uint32_t _flags_save_string = ndr->flags;
3595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3596                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3597                         ndr->flags = _flags_save_string;
3598                 }
3599                 {
3600                         uint32_t _flags_save_string = ndr->flags;
3601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3602                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3603                         ndr->flags = _flags_save_string;
3604                 }
3605                 {
3606                         uint32_t _flags_save_string = ndr->flags;
3607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3609                         ndr->flags = _flags_save_string;
3610                 }
3611                 {
3612                         uint32_t _flags_save_string = ndr->flags;
3613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3615                         ndr->flags = _flags_save_string;
3616                 }
3617                 {
3618                         uint32_t _flags_save_string = ndr->flags;
3619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3620                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3621                         ndr->flags = _flags_save_string;
3622                 }
3623                 {
3624                         uint32_t _flags_save_string = ndr->flags;
3625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3626                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3627                         ndr->flags = _flags_save_string;
3628                 }
3629                 {
3630                         uint32_t _flags_save_string = ndr->flags;
3631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3632                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3633                         ndr->flags = _flags_save_string;
3634                 }
3635                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3636                 {
3637                         uint32_t _flags_save_string = ndr->flags;
3638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3639                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3643                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3650                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3654         }
3655         if (ndr_flags & NDR_BUFFERS) {
3656                 {
3657                         uint32_t _flags_save_string = ndr->flags;
3658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3659                         if (r->printer_name) {
3660                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3661                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3662                         }
3663                         ndr->flags = _flags_save_string;
3664                 }
3665                 {
3666                         uint32_t _flags_save_string = ndr->flags;
3667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3668                         if (r->server_name) {
3669                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3670                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3671                         }
3672                         ndr->flags = _flags_save_string;
3673                 }
3674                 {
3675                         uint32_t _flags_save_string = ndr->flags;
3676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3677                         if (r->user_name) {
3678                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3680                         }
3681                         ndr->flags = _flags_save_string;
3682                 }
3683                 {
3684                         uint32_t _flags_save_string = ndr->flags;
3685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3686                         if (r->document_name) {
3687                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3688                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3689                         }
3690                         ndr->flags = _flags_save_string;
3691                 }
3692                 {
3693                         uint32_t _flags_save_string = ndr->flags;
3694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3695                         if (r->notify_name) {
3696                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3697                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3698                         }
3699                         ndr->flags = _flags_save_string;
3700                 }
3701                 {
3702                         uint32_t _flags_save_string = ndr->flags;
3703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3704                         if (r->data_type) {
3705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3707                         }
3708                         ndr->flags = _flags_save_string;
3709                 }
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->print_processor) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         if (r->parameters) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3725                         }
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         if (r->driver_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 if (r->devmode) {
3738                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3739                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3740                 }
3741                 {
3742                         uint32_t _flags_save_string = ndr->flags;
3743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3744                         if (r->text_status) {
3745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3746                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3747                         }
3748                         ndr->flags = _flags_save_string;
3749                 }
3750                 if (r->secdesc) {
3751                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3752                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3753                 }
3754         }
3755         return NDR_ERR_SUCCESS;
3756 }
3757
3758 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3759 {
3760         uint32_t _ptr_printer_name;
3761         TALLOC_CTX *_mem_save_printer_name_0;
3762         uint32_t _ptr_server_name;
3763         TALLOC_CTX *_mem_save_server_name_0;
3764         uint32_t _ptr_user_name;
3765         TALLOC_CTX *_mem_save_user_name_0;
3766         uint32_t _ptr_document_name;
3767         TALLOC_CTX *_mem_save_document_name_0;
3768         uint32_t _ptr_notify_name;
3769         TALLOC_CTX *_mem_save_notify_name_0;
3770         uint32_t _ptr_data_type;
3771         TALLOC_CTX *_mem_save_data_type_0;
3772         uint32_t _ptr_print_processor;
3773         TALLOC_CTX *_mem_save_print_processor_0;
3774         uint32_t _ptr_parameters;
3775         TALLOC_CTX *_mem_save_parameters_0;
3776         uint32_t _ptr_driver_name;
3777         TALLOC_CTX *_mem_save_driver_name_0;
3778         uint32_t _ptr_devmode;
3779         TALLOC_CTX *_mem_save_devmode_0;
3780         uint32_t _ptr_text_status;
3781         TALLOC_CTX *_mem_save_text_status_0;
3782         uint32_t _ptr_secdesc;
3783         TALLOC_CTX *_mem_save_secdesc_0;
3784         if (ndr_flags & NDR_SCALARS) {
3785                 NDR_CHECK(ndr_pull_align(ndr, 4));
3786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3787                 {
3788                         uint32_t _flags_save_string = ndr->flags;
3789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3791                         if (_ptr_printer_name) {
3792                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3794                         } else {
3795                                 r->printer_name = NULL;
3796                         }
3797                         ndr->flags = _flags_save_string;
3798                 }
3799                 {
3800                         uint32_t _flags_save_string = ndr->flags;
3801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3802                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3803                         if (_ptr_server_name) {
3804                                 NDR_PULL_ALLOC(ndr, r->server_name);
3805                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3806                         } else {
3807                                 r->server_name = NULL;
3808                         }
3809                         ndr->flags = _flags_save_string;
3810                 }
3811                 {
3812                         uint32_t _flags_save_string = ndr->flags;
3813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3815                         if (_ptr_user_name) {
3816                                 NDR_PULL_ALLOC(ndr, r->user_name);
3817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3818                         } else {
3819                                 r->user_name = NULL;
3820                         }
3821                         ndr->flags = _flags_save_string;
3822                 }
3823                 {
3824                         uint32_t _flags_save_string = ndr->flags;
3825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3826                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3827                         if (_ptr_document_name) {
3828                                 NDR_PULL_ALLOC(ndr, r->document_name);
3829                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3830                         } else {
3831                                 r->document_name = NULL;
3832                         }
3833                         ndr->flags = _flags_save_string;
3834                 }
3835                 {
3836                         uint32_t _flags_save_string = ndr->flags;
3837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3838                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3839                         if (_ptr_notify_name) {
3840                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3841                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3842                         } else {
3843                                 r->notify_name = NULL;
3844                         }
3845                         ndr->flags = _flags_save_string;
3846                 }
3847                 {
3848                         uint32_t _flags_save_string = ndr->flags;
3849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3850                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3851                         if (_ptr_data_type) {
3852                                 NDR_PULL_ALLOC(ndr, r->data_type);
3853                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3854                         } else {
3855                                 r->data_type = NULL;
3856                         }
3857                         ndr->flags = _flags_save_string;
3858                 }
3859                 {
3860                         uint32_t _flags_save_string = ndr->flags;
3861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3862                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3863                         if (_ptr_print_processor) {
3864                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3865                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3866                         } else {
3867                                 r->print_processor = NULL;
3868                         }
3869                         ndr->flags = _flags_save_string;
3870                 }
3871                 {
3872                         uint32_t _flags_save_string = ndr->flags;
3873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3875                         if (_ptr_parameters) {
3876                                 NDR_PULL_ALLOC(ndr, r->parameters);
3877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3878                         } else {
3879                                 r->parameters = NULL;
3880                         }
3881                         ndr->flags = _flags_save_string;
3882                 }
3883                 {
3884                         uint32_t _flags_save_string = ndr->flags;
3885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3887                         if (_ptr_driver_name) {
3888                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3890                         } else {
3891                                 r->driver_name = NULL;
3892                         }
3893                         ndr->flags = _flags_save_string;
3894                 }
3895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3896                 if (_ptr_devmode) {
3897                         NDR_PULL_ALLOC(ndr, r->devmode);
3898                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3899                 } else {
3900                         r->devmode = NULL;
3901                 }
3902                 {
3903                         uint32_t _flags_save_string = ndr->flags;
3904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3905                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3906                         if (_ptr_text_status) {
3907                                 NDR_PULL_ALLOC(ndr, r->text_status);
3908                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3909                         } else {
3910                                 r->text_status = NULL;
3911                         }
3912                         ndr->flags = _flags_save_string;
3913                 }
3914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3915                 if (_ptr_secdesc) {
3916                         NDR_PULL_ALLOC(ndr, r->secdesc);
3917                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3918                 } else {
3919                         r->secdesc = NULL;
3920                 }
3921                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3928                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3932         }
3933         if (ndr_flags & NDR_BUFFERS) {
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->printer_name) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3941                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->server_name) {
3953                                 uint32_t _relative_save_offset;
3954                                 _relative_save_offset = ndr->offset;
3955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3956                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3957                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->user_name) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3971                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3975                                 ndr->offset = _relative_save_offset;
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->document_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3986                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3990                                 ndr->offset = _relative_save_offset;
3991                         }
3992                         ndr->flags = _flags_save_string;
3993                 }
3994                 {
3995                         uint32_t _flags_save_string = ndr->flags;
3996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3997                         if (r->notify_name) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4001                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4005                                 ndr->offset = _relative_save_offset;
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_string = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4012                         if (r->data_type) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4016                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4020                                 ndr->offset = _relative_save_offset;
4021                         }
4022                         ndr->flags = _flags_save_string;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->print_processor) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4031                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4035                                 ndr->offset = _relative_save_offset;
4036                         }
4037                         ndr->flags = _flags_save_string;
4038                 }
4039                 {
4040                         uint32_t _flags_save_string = ndr->flags;
4041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4042                         if (r->parameters) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4046                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 {
4055                         uint32_t _flags_save_string = ndr->flags;
4056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4057                         if (r->driver_name) {
4058                                 uint32_t _relative_save_offset;
4059                                 _relative_save_offset = ndr->offset;
4060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4061                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4062                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4065                                 ndr->offset = _relative_save_offset;
4066                         }
4067                         ndr->flags = _flags_save_string;
4068                 }
4069                 if (r->devmode) {
4070                         uint32_t _relative_save_offset;
4071                         _relative_save_offset = ndr->offset;
4072                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4073                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4074                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4075                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4077                         ndr->offset = _relative_save_offset;
4078                 }
4079                 {
4080                         uint32_t _flags_save_string = ndr->flags;
4081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4082                         if (r->text_status) {
4083                                 uint32_t _relative_save_offset;
4084                                 _relative_save_offset = ndr->offset;
4085                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4086                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4087                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4088                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4089                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4090                                 ndr->offset = _relative_save_offset;
4091                         }
4092                         ndr->flags = _flags_save_string;
4093                 }
4094                 if (r->secdesc) {
4095                         uint32_t _relative_save_offset;
4096                         _relative_save_offset = ndr->offset;
4097                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4098                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4099                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4100                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4102                         ndr->offset = _relative_save_offset;
4103                 }
4104         }
4105         return NDR_ERR_SUCCESS;
4106 }
4107
4108 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4109 {
4110         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4111         ndr->depth++;
4112         ndr_print_uint32(ndr, "job_id", r->job_id);
4113         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4114         ndr->depth++;
4115         if (r->printer_name) {
4116                 ndr_print_string(ndr, "printer_name", r->printer_name);
4117         }
4118         ndr->depth--;
4119         ndr_print_ptr(ndr, "server_name", r->server_name);
4120         ndr->depth++;
4121         if (r->server_name) {
4122                 ndr_print_string(ndr, "server_name", r->server_name);
4123         }
4124         ndr->depth--;
4125         ndr_print_ptr(ndr, "user_name", r->user_name);
4126         ndr->depth++;
4127         if (r->user_name) {
4128                 ndr_print_string(ndr, "user_name", r->user_name);
4129         }
4130         ndr->depth--;
4131         ndr_print_ptr(ndr, "document_name", r->document_name);
4132         ndr->depth++;
4133         if (r->document_name) {
4134                 ndr_print_string(ndr, "document_name", r->document_name);
4135         }
4136         ndr->depth--;
4137         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4138         ndr->depth++;
4139         if (r->notify_name) {
4140                 ndr_print_string(ndr, "notify_name", r->notify_name);
4141         }
4142         ndr->depth--;
4143         ndr_print_ptr(ndr, "data_type", r->data_type);
4144         ndr->depth++;
4145         if (r->data_type) {
4146                 ndr_print_string(ndr, "data_type", r->data_type);
4147         }
4148         ndr->depth--;
4149         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4150         ndr->depth++;
4151         if (r->print_processor) {
4152                 ndr_print_string(ndr, "print_processor", r->print_processor);
4153         }
4154         ndr->depth--;
4155         ndr_print_ptr(ndr, "parameters", r->parameters);
4156         ndr->depth++;
4157         if (r->parameters) {
4158                 ndr_print_string(ndr, "parameters", r->parameters);
4159         }
4160         ndr->depth--;
4161         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4162         ndr->depth++;
4163         if (r->driver_name) {
4164                 ndr_print_string(ndr, "driver_name", r->driver_name);
4165         }
4166         ndr->depth--;
4167         ndr_print_ptr(ndr, "devmode", r->devmode);
4168         ndr->depth++;
4169         if (r->devmode) {
4170                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4171         }
4172         ndr->depth--;
4173         ndr_print_ptr(ndr, "text_status", r->text_status);
4174         ndr->depth++;
4175         if (r->text_status) {
4176                 ndr_print_string(ndr, "text_status", r->text_status);
4177         }
4178         ndr->depth--;
4179         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4180         ndr->depth++;
4181         if (r->secdesc) {
4182                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4183         }
4184         ndr->depth--;
4185         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4186         ndr_print_uint32(ndr, "priority", r->priority);
4187         ndr_print_uint32(ndr, "position", r->position);
4188         ndr_print_uint32(ndr, "start_time", r->start_time);
4189         ndr_print_uint32(ndr, "until_time", r->until_time);
4190         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4191         ndr_print_uint32(ndr, "size", r->size);
4192         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4193         ndr_print_uint32(ndr, "time", r->time);
4194         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4195         ndr_print_uint32(ndr, "size_high", r->size_high);
4196         ndr->depth--;
4197 }
4198
4199 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4200 {
4201         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4202 }
4203
4204 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4205 {
4206         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4207         if (ndr_flags & NDR_SCALARS) {
4208                 int level = ndr_push_get_switch_value(ndr, r);
4209                 switch (level) {
4210                         case 1: {
4211                                 NDR_CHECK(ndr_push_align(ndr, 4));
4212                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4213                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4214                         break; }
4215
4216                         case 2: {
4217                                 NDR_CHECK(ndr_push_align(ndr, 4));
4218                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4219                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4220                         break; }
4221
4222                         case 3: {
4223                                 NDR_CHECK(ndr_push_align(ndr, 4));
4224                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4225                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4226                         break; }
4227
4228                         case 4: {
4229                                 NDR_CHECK(ndr_push_align(ndr, 4));
4230                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4231                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4232                         break; }
4233
4234                         default: {
4235                         break; }
4236
4237                 }
4238         }
4239         if (ndr_flags & NDR_BUFFERS) {
4240                 int level = ndr_push_get_switch_value(ndr, r);
4241                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4242                 switch (level) {
4243                         case 1:
4244                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4245                         break;
4246
4247                         case 2:
4248                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4249                         break;
4250
4251                         case 3:
4252                         break;
4253
4254                         case 4:
4255                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4256                         break;
4257
4258                         default:
4259                         break;
4260
4261                 }
4262         }
4263         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4264         return NDR_ERR_SUCCESS;
4265 }
4266
4267 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4268 {
4269         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4270         int level;
4271         level = ndr_pull_get_switch_value(ndr, r);
4272         if (ndr_flags & NDR_SCALARS) {
4273                 switch (level) {
4274                         case 1: {
4275                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4276                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4277                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4278                         break; }
4279
4280                         case 2: {
4281                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4282                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4283                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4284                         break; }
4285
4286                         case 3: {
4287                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4288                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4289                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4290                         break; }
4291
4292                         case 4: {
4293                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4294                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4295                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4296                         break; }
4297
4298                         default: {
4299                         break; }
4300
4301                 }
4302         }
4303         if (ndr_flags & NDR_BUFFERS) {
4304                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4305                 switch (level) {
4306                         case 1:
4307                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4308                         break;
4309
4310                         case 2:
4311                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4312                         break;
4313
4314                         case 3:
4315                         break;
4316
4317                         case 4:
4318                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4319                         break;
4320
4321                         default:
4322                         break;
4323
4324                 }
4325         }
4326         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4331 {
4332         int level;
4333         level = ndr_print_get_switch_value(ndr, r);
4334         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4335         switch (level) {
4336                 case 1:
4337                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4338                 break;
4339
4340                 case 2:
4341                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4342                 break;
4343
4344                 case 3:
4345                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4346                 break;
4347
4348                 case 4:
4349                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4350                 break;
4351
4352                 default:
4353                 break;
4354
4355         }
4356 }
4357
4358 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4359 {
4360         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4361 }
4362
4363 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4364 {
4365         if (ndr_flags & NDR_SCALARS) {
4366                 NDR_CHECK(ndr_push_align(ndr, 4));
4367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4374                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4379                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4380         }
4381         if (ndr_flags & NDR_BUFFERS) {
4382                 if (r->printer_name) {
4383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4387                 }
4388                 if (r->server_name) {
4389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4393                 }
4394                 if (r->user_name) {
4395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4399                 }
4400                 if (r->document_name) {
4401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4405                 }
4406                 if (r->data_type) {
4407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4411                 }
4412                 if (r->text_status) {
4413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4417                 }
4418         }
4419         return NDR_ERR_SUCCESS;
4420 }
4421
4422 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4423 {
4424         uint32_t _ptr_printer_name;
4425         TALLOC_CTX *_mem_save_printer_name_0;
4426         uint32_t _ptr_server_name;
4427         TALLOC_CTX *_mem_save_server_name_0;
4428         uint32_t _ptr_user_name;
4429         TALLOC_CTX *_mem_save_user_name_0;
4430         uint32_t _ptr_document_name;
4431         TALLOC_CTX *_mem_save_document_name_0;
4432         uint32_t _ptr_data_type;
4433         TALLOC_CTX *_mem_save_data_type_0;
4434         uint32_t _ptr_text_status;
4435         TALLOC_CTX *_mem_save_text_status_0;
4436         if (ndr_flags & NDR_SCALARS) {
4437                 NDR_CHECK(ndr_pull_align(ndr, 4));
4438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4440                 if (_ptr_printer_name) {
4441                         NDR_PULL_ALLOC(ndr, r->printer_name);
4442                 } else {
4443                         r->printer_name = NULL;
4444                 }
4445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4446                 if (_ptr_server_name) {
4447                         NDR_PULL_ALLOC(ndr, r->server_name);
4448                 } else {
4449                         r->server_name = NULL;
4450                 }
4451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4452                 if (_ptr_user_name) {
4453                         NDR_PULL_ALLOC(ndr, r->user_name);
4454                 } else {
4455                         r->user_name = NULL;
4456                 }
4457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4458                 if (_ptr_document_name) {
4459                         NDR_PULL_ALLOC(ndr, r->document_name);
4460                 } else {
4461                         r->document_name = NULL;
4462                 }
4463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4464                 if (_ptr_data_type) {
4465                         NDR_PULL_ALLOC(ndr, r->data_type);
4466                 } else {
4467                         r->data_type = NULL;
4468                 }
4469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4470                 if (_ptr_text_status) {
4471                         NDR_PULL_ALLOC(ndr, r->text_status);
4472                 } else {
4473                         r->text_status = NULL;
4474                 }
4475                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4480                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4481         }
4482         if (ndr_flags & NDR_BUFFERS) {
4483                 if (r->printer_name) {
4484                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4485                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4488                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4489                                 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));
4490                         }
4491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4494                 }
4495                 if (r->server_name) {
4496                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4498                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4499                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4500                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4501                                 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));
4502                         }
4503                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4504                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4506                 }
4507                 if (r->user_name) {
4508                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4509                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4512                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4513                                 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));
4514                         }
4515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4518                 }
4519                 if (r->document_name) {
4520                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4521                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4522                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4523                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4524                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4525                                 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));
4526                         }
4527                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4528                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4530                 }
4531                 if (r->data_type) {
4532                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4535                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4536                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4537                                 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));
4538                         }
4539                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4540                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4542                 }
4543                 if (r->text_status) {
4544                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4548                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4549                                 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));
4550                         }
4551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4554                 }
4555         }
4556         return NDR_ERR_SUCCESS;
4557 }
4558
4559 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4560 {
4561         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4562         ndr->depth++;
4563         ndr_print_uint32(ndr, "job_id", r->job_id);
4564         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4565         ndr->depth++;
4566         if (r->printer_name) {
4567                 ndr_print_string(ndr, "printer_name", r->printer_name);
4568         }
4569         ndr->depth--;
4570         ndr_print_ptr(ndr, "server_name", r->server_name);
4571         ndr->depth++;
4572         if (r->server_name) {
4573                 ndr_print_string(ndr, "server_name", r->server_name);
4574         }
4575         ndr->depth--;
4576         ndr_print_ptr(ndr, "user_name", r->user_name);
4577         ndr->depth++;
4578         if (r->user_name) {
4579                 ndr_print_string(ndr, "user_name", r->user_name);
4580         }
4581         ndr->depth--;
4582         ndr_print_ptr(ndr, "document_name", r->document_name);
4583         ndr->depth++;
4584         if (r->document_name) {
4585                 ndr_print_string(ndr, "document_name", r->document_name);
4586         }
4587         ndr->depth--;
4588         ndr_print_ptr(ndr, "data_type", r->data_type);
4589         ndr->depth++;
4590         if (r->data_type) {
4591                 ndr_print_string(ndr, "data_type", r->data_type);
4592         }
4593         ndr->depth--;
4594         ndr_print_ptr(ndr, "text_status", r->text_status);
4595         ndr->depth++;
4596         if (r->text_status) {
4597                 ndr_print_string(ndr, "text_status", r->text_status);
4598         }
4599         ndr->depth--;
4600         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4601         ndr_print_uint32(ndr, "priority", r->priority);
4602         ndr_print_uint32(ndr, "position", r->position);
4603         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4604         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4605         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4606         ndr->depth--;
4607 }
4608
4609 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4610 {
4611         if (ndr_flags & NDR_SCALARS) {
4612                 NDR_CHECK(ndr_push_align(ndr, 4));
4613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4626                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4633                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4636         }
4637         if (ndr_flags & NDR_BUFFERS) {
4638                 if (r->printer_name) {
4639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4642                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4643                 }
4644                 if (r->server_name) {
4645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4649                 }
4650                 if (r->user_name) {
4651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4655                 }
4656                 if (r->document_name) {
4657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4661                 }
4662                 if (r->notify_name) {
4663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4667                 }
4668                 if (r->data_type) {
4669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4672                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4673                 }
4674                 if (r->print_processor) {
4675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4678                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4679                 }
4680                 if (r->parameters) {
4681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4685                 }
4686                 if (r->driver_name) {
4687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4691                 }
4692                 if (r->text_status) {
4693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4696                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4697                 }
4698         }
4699         return NDR_ERR_SUCCESS;
4700 }
4701
4702 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4703 {
4704         uint32_t _ptr_printer_name;
4705         TALLOC_CTX *_mem_save_printer_name_0;
4706         uint32_t _ptr_server_name;
4707         TALLOC_CTX *_mem_save_server_name_0;
4708         uint32_t _ptr_user_name;
4709         TALLOC_CTX *_mem_save_user_name_0;
4710         uint32_t _ptr_document_name;
4711         TALLOC_CTX *_mem_save_document_name_0;
4712         uint32_t _ptr_notify_name;
4713         TALLOC_CTX *_mem_save_notify_name_0;
4714         uint32_t _ptr_data_type;
4715         TALLOC_CTX *_mem_save_data_type_0;
4716         uint32_t _ptr_print_processor;
4717         TALLOC_CTX *_mem_save_print_processor_0;
4718         uint32_t _ptr_parameters;
4719         TALLOC_CTX *_mem_save_parameters_0;
4720         uint32_t _ptr_driver_name;
4721         TALLOC_CTX *_mem_save_driver_name_0;
4722         uint32_t _ptr_text_status;
4723         TALLOC_CTX *_mem_save_text_status_0;
4724         if (ndr_flags & NDR_SCALARS) {
4725                 NDR_CHECK(ndr_pull_align(ndr, 4));
4726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4728                 if (_ptr_printer_name) {
4729                         NDR_PULL_ALLOC(ndr, r->printer_name);
4730                 } else {
4731                         r->printer_name = NULL;
4732                 }
4733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4734                 if (_ptr_server_name) {
4735                         NDR_PULL_ALLOC(ndr, r->server_name);
4736                 } else {
4737                         r->server_name = NULL;
4738                 }
4739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4740                 if (_ptr_user_name) {
4741                         NDR_PULL_ALLOC(ndr, r->user_name);
4742                 } else {
4743                         r->user_name = NULL;
4744                 }
4745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4746                 if (_ptr_document_name) {
4747                         NDR_PULL_ALLOC(ndr, r->document_name);
4748                 } else {
4749                         r->document_name = NULL;
4750                 }
4751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4752                 if (_ptr_notify_name) {
4753                         NDR_PULL_ALLOC(ndr, r->notify_name);
4754                 } else {
4755                         r->notify_name = NULL;
4756                 }
4757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4758                 if (_ptr_data_type) {
4759                         NDR_PULL_ALLOC(ndr, r->data_type);
4760                 } else {
4761                         r->data_type = NULL;
4762                 }
4763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4764                 if (_ptr_print_processor) {
4765                         NDR_PULL_ALLOC(ndr, r->print_processor);
4766                 } else {
4767                         r->print_processor = NULL;
4768                 }
4769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4770                 if (_ptr_parameters) {
4771                         NDR_PULL_ALLOC(ndr, r->parameters);
4772                 } else {
4773                         r->parameters = NULL;
4774                 }
4775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4776                 if (_ptr_driver_name) {
4777                         NDR_PULL_ALLOC(ndr, r->driver_name);
4778                 } else {
4779                         r->driver_name = NULL;
4780                 }
4781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4783                 if (_ptr_text_status) {
4784                         NDR_PULL_ALLOC(ndr, r->text_status);
4785                 } else {
4786                         r->text_status = NULL;
4787                 }
4788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4789                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4796                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4799         }
4800         if (ndr_flags & NDR_BUFFERS) {
4801                 if (r->printer_name) {
4802                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4803                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4806                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4807                                 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));
4808                         }
4809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4812                 }
4813                 if (r->server_name) {
4814                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4815                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4818                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4819                                 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));
4820                         }
4821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4824                 }
4825                 if (r->user_name) {
4826                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4827                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4830                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4831                                 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));
4832                         }
4833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4836                 }
4837                 if (r->document_name) {
4838                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4839                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4842                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4843                                 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));
4844                         }
4845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4848                 }
4849                 if (r->notify_name) {
4850                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4851                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4854                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4855                                 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));
4856                         }
4857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4860                 }
4861                 if (r->data_type) {
4862                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4863                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4866                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4867                                 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));
4868                         }
4869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4872                 }
4873                 if (r->print_processor) {
4874                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4875                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4878                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4879                                 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));
4880                         }
4881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4884                 }
4885                 if (r->parameters) {
4886                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4887                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4890                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4891                                 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));
4892                         }
4893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4896                 }
4897                 if (r->driver_name) {
4898                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4899                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4902                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4903                                 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));
4904                         }
4905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4908                 }
4909                 if (r->text_status) {
4910                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4911                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4913                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4914                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4915                                 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));
4916                         }
4917                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4918                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4920                 }
4921         }
4922         return NDR_ERR_SUCCESS;
4923 }
4924
4925 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4926 {
4927         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4928         ndr->depth++;
4929         ndr_print_uint32(ndr, "job_id", r->job_id);
4930         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4931         ndr->depth++;
4932         if (r->printer_name) {
4933                 ndr_print_string(ndr, "printer_name", r->printer_name);
4934         }
4935         ndr->depth--;
4936         ndr_print_ptr(ndr, "server_name", r->server_name);
4937         ndr->depth++;
4938         if (r->server_name) {
4939                 ndr_print_string(ndr, "server_name", r->server_name);
4940         }
4941         ndr->depth--;
4942         ndr_print_ptr(ndr, "user_name", r->user_name);
4943         ndr->depth++;
4944         if (r->user_name) {
4945                 ndr_print_string(ndr, "user_name", r->user_name);
4946         }
4947         ndr->depth--;
4948         ndr_print_ptr(ndr, "document_name", r->document_name);
4949         ndr->depth++;
4950         if (r->document_name) {
4951                 ndr_print_string(ndr, "document_name", r->document_name);
4952         }
4953         ndr->depth--;
4954         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4955         ndr->depth++;
4956         if (r->notify_name) {
4957                 ndr_print_string(ndr, "notify_name", r->notify_name);
4958         }
4959         ndr->depth--;
4960         ndr_print_ptr(ndr, "data_type", r->data_type);
4961         ndr->depth++;
4962         if (r->data_type) {
4963                 ndr_print_string(ndr, "data_type", r->data_type);
4964         }
4965         ndr->depth--;
4966         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4967         ndr->depth++;
4968         if (r->print_processor) {
4969                 ndr_print_string(ndr, "print_processor", r->print_processor);
4970         }
4971         ndr->depth--;
4972         ndr_print_ptr(ndr, "parameters", r->parameters);
4973         ndr->depth++;
4974         if (r->parameters) {
4975                 ndr_print_string(ndr, "parameters", r->parameters);
4976         }
4977         ndr->depth--;
4978         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4979         ndr->depth++;
4980         if (r->driver_name) {
4981                 ndr_print_string(ndr, "driver_name", r->driver_name);
4982         }
4983         ndr->depth--;
4984         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
4985         ndr_print_ptr(ndr, "text_status", r->text_status);
4986         ndr->depth++;
4987         if (r->text_status) {
4988                 ndr_print_string(ndr, "text_status", r->text_status);
4989         }
4990         ndr->depth--;
4991         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
4992         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4993         ndr_print_uint32(ndr, "priority", r->priority);
4994         ndr_print_uint32(ndr, "position", r->position);
4995         ndr_print_uint32(ndr, "start_time", r->start_time);
4996         ndr_print_uint32(ndr, "until_time", r->until_time);
4997         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4998         ndr_print_uint32(ndr, "size", r->size);
4999         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5000         ndr_print_uint32(ndr, "time", r->time);
5001         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5002         ndr->depth--;
5003 }
5004
5005 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5006 {
5007         if (ndr_flags & NDR_SCALARS) {
5008                 NDR_CHECK(ndr_push_align(ndr, 4));
5009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5022                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5029                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5033         }
5034         if (ndr_flags & NDR_BUFFERS) {
5035                 if (r->printer_name) {
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5039                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5040                 }
5041                 if (r->server_name) {
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5046                 }
5047                 if (r->user_name) {
5048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5052                 }
5053                 if (r->document_name) {
5054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5058                 }
5059                 if (r->notify_name) {
5060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5064                 }
5065                 if (r->data_type) {
5066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5069                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5070                 }
5071                 if (r->print_processor) {
5072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5076                 }
5077                 if (r->parameters) {
5078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5081                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5082                 }
5083                 if (r->driver_name) {
5084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5088                 }
5089                 if (r->text_status) {
5090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5094                 }
5095         }
5096         return NDR_ERR_SUCCESS;
5097 }
5098
5099 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5100 {
5101         uint32_t _ptr_printer_name;
5102         TALLOC_CTX *_mem_save_printer_name_0;
5103         uint32_t _ptr_server_name;
5104         TALLOC_CTX *_mem_save_server_name_0;
5105         uint32_t _ptr_user_name;
5106         TALLOC_CTX *_mem_save_user_name_0;
5107         uint32_t _ptr_document_name;
5108         TALLOC_CTX *_mem_save_document_name_0;
5109         uint32_t _ptr_notify_name;
5110         TALLOC_CTX *_mem_save_notify_name_0;
5111         uint32_t _ptr_data_type;
5112         TALLOC_CTX *_mem_save_data_type_0;
5113         uint32_t _ptr_print_processor;
5114         TALLOC_CTX *_mem_save_print_processor_0;
5115         uint32_t _ptr_parameters;
5116         TALLOC_CTX *_mem_save_parameters_0;
5117         uint32_t _ptr_driver_name;
5118         TALLOC_CTX *_mem_save_driver_name_0;
5119         uint32_t _ptr_text_status;
5120         TALLOC_CTX *_mem_save_text_status_0;
5121         if (ndr_flags & NDR_SCALARS) {
5122                 NDR_CHECK(ndr_pull_align(ndr, 4));
5123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5125                 if (_ptr_printer_name) {
5126                         NDR_PULL_ALLOC(ndr, r->printer_name);
5127                 } else {
5128                         r->printer_name = NULL;
5129                 }
5130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5131                 if (_ptr_server_name) {
5132                         NDR_PULL_ALLOC(ndr, r->server_name);
5133                 } else {
5134                         r->server_name = NULL;
5135                 }
5136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5137                 if (_ptr_user_name) {
5138                         NDR_PULL_ALLOC(ndr, r->user_name);
5139                 } else {
5140                         r->user_name = NULL;
5141                 }
5142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5143                 if (_ptr_document_name) {
5144                         NDR_PULL_ALLOC(ndr, r->document_name);
5145                 } else {
5146                         r->document_name = NULL;
5147                 }
5148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5149                 if (_ptr_notify_name) {
5150                         NDR_PULL_ALLOC(ndr, r->notify_name);
5151                 } else {
5152                         r->notify_name = NULL;
5153                 }
5154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5155                 if (_ptr_data_type) {
5156                         NDR_PULL_ALLOC(ndr, r->data_type);
5157                 } else {
5158                         r->data_type = NULL;
5159                 }
5160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5161                 if (_ptr_print_processor) {
5162                         NDR_PULL_ALLOC(ndr, r->print_processor);
5163                 } else {
5164                         r->print_processor = NULL;
5165                 }
5166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5167                 if (_ptr_parameters) {
5168                         NDR_PULL_ALLOC(ndr, r->parameters);
5169                 } else {
5170                         r->parameters = NULL;
5171                 }
5172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5173                 if (_ptr_driver_name) {
5174                         NDR_PULL_ALLOC(ndr, r->driver_name);
5175                 } else {
5176                         r->driver_name = NULL;
5177                 }
5178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5180                 if (_ptr_text_status) {
5181                         NDR_PULL_ALLOC(ndr, r->text_status);
5182                 } else {
5183                         r->text_status = NULL;
5184                 }
5185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5186                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5193                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5197         }
5198         if (ndr_flags & NDR_BUFFERS) {
5199                 if (r->printer_name) {
5200                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5201                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5204                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5205                                 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));
5206                         }
5207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5208                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5210                 }
5211                 if (r->server_name) {
5212                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5213                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5216                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5217                                 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));
5218                         }
5219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5222                 }
5223                 if (r->user_name) {
5224                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5225                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5226                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5227                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5228                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5229                                 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));
5230                         }
5231                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5232                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5234                 }
5235                 if (r->document_name) {
5236                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5237                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5240                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5241                                 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));
5242                         }
5243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5246                 }
5247                 if (r->notify_name) {
5248                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5249                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5252                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5253                                 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));
5254                         }
5255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5258                 }
5259                 if (r->data_type) {
5260                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5261                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5264                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5265                                 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));
5266                         }
5267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5270                 }
5271                 if (r->print_processor) {
5272                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5273                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5276                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5277                                 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));
5278                         }
5279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5282                 }
5283                 if (r->parameters) {
5284                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5285                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5288                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5289                                 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));
5290                         }
5291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5294                 }
5295                 if (r->driver_name) {
5296                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5297                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5299                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5300                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5301                                 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));
5302                         }
5303                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5304                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5306                 }
5307                 if (r->text_status) {
5308                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5309                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5312                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5313                                 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));
5314                         }
5315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5318                 }
5319         }
5320         return NDR_ERR_SUCCESS;
5321 }
5322
5323 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5324 {
5325         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5326         ndr->depth++;
5327         ndr_print_uint32(ndr, "job_id", r->job_id);
5328         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5329         ndr->depth++;
5330         if (r->printer_name) {
5331                 ndr_print_string(ndr, "printer_name", r->printer_name);
5332         }
5333         ndr->depth--;
5334         ndr_print_ptr(ndr, "server_name", r->server_name);
5335         ndr->depth++;
5336         if (r->server_name) {
5337                 ndr_print_string(ndr, "server_name", r->server_name);
5338         }
5339         ndr->depth--;
5340         ndr_print_ptr(ndr, "user_name", r->user_name);
5341         ndr->depth++;
5342         if (r->user_name) {
5343                 ndr_print_string(ndr, "user_name", r->user_name);
5344         }
5345         ndr->depth--;
5346         ndr_print_ptr(ndr, "document_name", r->document_name);
5347         ndr->depth++;
5348         if (r->document_name) {
5349                 ndr_print_string(ndr, "document_name", r->document_name);
5350         }
5351         ndr->depth--;
5352         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5353         ndr->depth++;
5354         if (r->notify_name) {
5355                 ndr_print_string(ndr, "notify_name", r->notify_name);
5356         }
5357         ndr->depth--;
5358         ndr_print_ptr(ndr, "data_type", r->data_type);
5359         ndr->depth++;
5360         if (r->data_type) {
5361                 ndr_print_string(ndr, "data_type", r->data_type);
5362         }
5363         ndr->depth--;
5364         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5365         ndr->depth++;
5366         if (r->print_processor) {
5367                 ndr_print_string(ndr, "print_processor", r->print_processor);
5368         }
5369         ndr->depth--;
5370         ndr_print_ptr(ndr, "parameters", r->parameters);
5371         ndr->depth++;
5372         if (r->parameters) {
5373                 ndr_print_string(ndr, "parameters", r->parameters);
5374         }
5375         ndr->depth--;
5376         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5377         ndr->depth++;
5378         if (r->driver_name) {
5379                 ndr_print_string(ndr, "driver_name", r->driver_name);
5380         }
5381         ndr->depth--;
5382         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5383         ndr_print_ptr(ndr, "text_status", r->text_status);
5384         ndr->depth++;
5385         if (r->text_status) {
5386                 ndr_print_string(ndr, "text_status", r->text_status);
5387         }
5388         ndr->depth--;
5389         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5390         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5391         ndr_print_uint32(ndr, "priority", r->priority);
5392         ndr_print_uint32(ndr, "position", r->position);
5393         ndr_print_uint32(ndr, "start_time", r->start_time);
5394         ndr_print_uint32(ndr, "until_time", r->until_time);
5395         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5396         ndr_print_uint32(ndr, "size", r->size);
5397         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5398         ndr_print_uint32(ndr, "time", r->time);
5399         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5400         ndr_print_uint32(ndr, "size_high", r->size_high);
5401         ndr->depth--;
5402 }
5403
5404 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5405 {
5406         if (ndr_flags & NDR_SCALARS) {
5407                 int level = ndr_push_get_switch_value(ndr, r);
5408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5409                 switch (level) {
5410                         case 1: {
5411                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5412                         break; }
5413
5414                         case 2: {
5415                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5416                         break; }
5417
5418                         case 3: {
5419                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5420                         break; }
5421
5422                         case 4: {
5423                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5424                         break; }
5425
5426                         default: {
5427                         break; }
5428
5429                 }
5430         }
5431         if (ndr_flags & NDR_BUFFERS) {
5432                 int level = ndr_push_get_switch_value(ndr, r);
5433                 switch (level) {
5434                         case 1:
5435                                 if (r->info1) {
5436                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5437                                 }
5438                         break;
5439
5440                         case 2:
5441                                 if (r->info2) {
5442                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5443                                 }
5444                         break;
5445
5446                         case 3:
5447                                 if (r->info3) {
5448                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5449                                 }
5450                         break;
5451
5452                         case 4:
5453                                 if (r->info4) {
5454                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5455                                 }
5456                         break;
5457
5458                         default:
5459                         break;
5460
5461                 }
5462         }
5463         return NDR_ERR_SUCCESS;
5464 }
5465
5466 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5467 {
5468         int level;
5469         uint32_t _level;
5470         TALLOC_CTX *_mem_save_info1_0;
5471         TALLOC_CTX *_mem_save_info2_0;
5472         TALLOC_CTX *_mem_save_info3_0;
5473         TALLOC_CTX *_mem_save_info4_0;
5474         level = ndr_pull_get_switch_value(ndr, r);
5475         if (ndr_flags & NDR_SCALARS) {
5476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5477                 if (_level != level) {
5478                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5479                 }
5480                 switch (level) {
5481                         case 1: {
5482                                 uint32_t _ptr_info1;
5483                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5484                                 if (_ptr_info1) {
5485                                         NDR_PULL_ALLOC(ndr, r->info1);
5486                                 } else {
5487                                         r->info1 = NULL;
5488                                 }
5489                         break; }
5490
5491                         case 2: {
5492                                 uint32_t _ptr_info2;
5493                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5494                                 if (_ptr_info2) {
5495                                         NDR_PULL_ALLOC(ndr, r->info2);
5496                                 } else {
5497                                         r->info2 = NULL;
5498                                 }
5499                         break; }
5500
5501                         case 3: {
5502                                 uint32_t _ptr_info3;
5503                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5504                                 if (_ptr_info3) {
5505                                         NDR_PULL_ALLOC(ndr, r->info3);
5506                                 } else {
5507                                         r->info3 = NULL;
5508                                 }
5509                         break; }
5510
5511                         case 4: {
5512                                 uint32_t _ptr_info4;
5513                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5514                                 if (_ptr_info4) {
5515                                         NDR_PULL_ALLOC(ndr, r->info4);
5516                                 } else {
5517                                         r->info4 = NULL;
5518                                 }
5519                         break; }
5520
5521                         default: {
5522                         break; }
5523
5524                 }
5525         }
5526         if (ndr_flags & NDR_BUFFERS) {
5527                 switch (level) {
5528                         case 1:
5529                                 if (r->info1) {
5530                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5531                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5532                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5533                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5534                                 }
5535                         break;
5536
5537                         case 2:
5538                                 if (r->info2) {
5539                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5540                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5541                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5542                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5543                                 }
5544                         break;
5545
5546                         case 3:
5547                                 if (r->info3) {
5548                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5549                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5550                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5551                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5552                                 }
5553                         break;
5554
5555                         case 4:
5556                                 if (r->info4) {
5557                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5558                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5559                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5560                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5561                                 }
5562                         break;
5563
5564                         default:
5565                         break;
5566
5567                 }
5568         }
5569         return NDR_ERR_SUCCESS;
5570 }
5571
5572 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5573 {
5574         int level;
5575         level = ndr_print_get_switch_value(ndr, r);
5576         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5577         switch (level) {
5578                 case 1:
5579                         ndr_print_ptr(ndr, "info1", r->info1);
5580                         ndr->depth++;
5581                         if (r->info1) {
5582                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5583                         }
5584                         ndr->depth--;
5585                 break;
5586
5587                 case 2:
5588                         ndr_print_ptr(ndr, "info2", r->info2);
5589                         ndr->depth++;
5590                         if (r->info2) {
5591                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5592                         }
5593                         ndr->depth--;
5594                 break;
5595
5596                 case 3:
5597                         ndr_print_ptr(ndr, "info3", r->info3);
5598                         ndr->depth++;
5599                         if (r->info3) {
5600                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5601                         }
5602                         ndr->depth--;
5603                 break;
5604
5605                 case 4:
5606                         ndr_print_ptr(ndr, "info4", r->info4);
5607                         ndr->depth++;
5608                         if (r->info4) {
5609                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5610                         }
5611                         ndr->depth--;
5612                 break;
5613
5614                 default:
5615                 break;
5616
5617         }
5618 }
5619
5620 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5621 {
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_push_align(ndr, 4));
5624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5625                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5626                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5627         }
5628         if (ndr_flags & NDR_BUFFERS) {
5629                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5630         }
5631         return NDR_ERR_SUCCESS;
5632 }
5633
5634 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5635 {
5636         if (ndr_flags & NDR_SCALARS) {
5637                 NDR_CHECK(ndr_pull_align(ndr, 4));
5638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5639                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5640                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5641         }
5642         if (ndr_flags & NDR_BUFFERS) {
5643                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5644         }
5645         return NDR_ERR_SUCCESS;
5646 }
5647
5648 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5649 {
5650         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5651         ndr->depth++;
5652         ndr_print_uint32(ndr, "level", r->level);
5653         ndr_print_set_switch_value(ndr, &r->info, r->level);
5654         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5655         ndr->depth--;
5656 }
5657
5658 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5659 {
5660         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5665 {
5666         uint32_t v;
5667         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5668         *r = v;
5669         return NDR_ERR_SUCCESS;
5670 }
5671
5672 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5673 {
5674         const char *val = NULL;
5675
5676         switch (r) {
5677                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5678                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5679                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5680                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5681                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5682                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5683                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5684                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5685                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5686         }
5687         ndr_print_enum(ndr, name, "ENUM", val, r);
5688 }
5689
5690 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5691 {
5692         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5693         return NDR_ERR_SUCCESS;
5694 }
5695
5696 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5697 {
5698         uint32_t v;
5699         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5700         *r = v;
5701         return NDR_ERR_SUCCESS;
5702 }
5703
5704 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5705 {
5706         const char *val = NULL;
5707
5708         switch (r) {
5709                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5710                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5711                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5712                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5713                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5714         }
5715         ndr_print_enum(ndr, name, "ENUM", val, r);
5716 }
5717
5718 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5719 {
5720         if (ndr_flags & NDR_SCALARS) {
5721                 NDR_CHECK(ndr_push_align(ndr, 4));
5722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5727                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5739                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5742                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5746                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5747                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5751         }
5752         if (ndr_flags & NDR_BUFFERS) {
5753                 if (r->servername) {
5754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5758                 }
5759                 if (r->printername) {
5760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5764                 }
5765         }
5766         return NDR_ERR_SUCCESS;
5767 }
5768
5769 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5770 {
5771         uint32_t _ptr_servername;
5772         TALLOC_CTX *_mem_save_servername_0;
5773         uint32_t _ptr_printername;
5774         TALLOC_CTX *_mem_save_printername_0;
5775         if (ndr_flags & NDR_SCALARS) {
5776                 NDR_CHECK(ndr_pull_align(ndr, 4));
5777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5778                 if (_ptr_servername) {
5779                         NDR_PULL_ALLOC(ndr, r->servername);
5780                 } else {
5781                         r->servername = NULL;
5782                 }
5783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5784                 if (_ptr_printername) {
5785                         NDR_PULL_ALLOC(ndr, r->printername);
5786                 } else {
5787                         r->printername = NULL;
5788                 }
5789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5792                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5804                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5811                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5812                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5816         }
5817         if (ndr_flags & NDR_BUFFERS) {
5818                 if (r->servername) {
5819                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5820                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5823                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5824                                 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));
5825                         }
5826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5829                 }
5830                 if (r->printername) {
5831                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5832                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5834                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5835                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5836                                 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));
5837                         }
5838                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5839                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5841                 }
5842         }
5843         return NDR_ERR_SUCCESS;
5844 }
5845
5846 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5847 {
5848         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5849         ndr->depth++;
5850         ndr_print_ptr(ndr, "servername", r->servername);
5851         ndr->depth++;
5852         if (r->servername) {
5853                 ndr_print_string(ndr, "servername", r->servername);
5854         }
5855         ndr->depth--;
5856         ndr_print_ptr(ndr, "printername", r->printername);
5857         ndr->depth++;
5858         if (r->printername) {
5859                 ndr_print_string(ndr, "printername", r->printername);
5860         }
5861         ndr->depth--;
5862         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5863         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5864         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5865         ndr_print_spoolss_Time(ndr, "time", &r->time);
5866         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5867         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5868         ndr_print_uint32(ndr, "version", r->version);
5869         ndr_print_uint32(ndr, "free_build", r->free_build);
5870         ndr_print_uint32(ndr, "spooling", r->spooling);
5871         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5872         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5873         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5874         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5875         ndr_print_uint32(ndr, "job_error", r->job_error);
5876         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5877         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5878         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5879         ndr_print_uint32(ndr, "change_id", r->change_id);
5880         ndr_print_WERROR(ndr, "last_error", r->last_error);
5881         ndr_print_uint32(ndr, "status", r->status);
5882         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5883         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5884         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5885         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5886         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5887         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5888         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5889         ndr->depth--;
5890 }
5891
5892 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5893 {
5894         if (ndr_flags & NDR_SCALARS) {
5895                 NDR_CHECK(ndr_push_align(ndr, 4));
5896                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5900         }
5901         if (ndr_flags & NDR_BUFFERS) {
5902                 if (r->name) {
5903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5907                 }
5908                 if (r->description) {
5909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5913                 }
5914                 if (r->comment) {
5915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5919                 }
5920         }
5921         return NDR_ERR_SUCCESS;
5922 }
5923
5924 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5925 {
5926         uint32_t _ptr_name;
5927         TALLOC_CTX *_mem_save_name_0;
5928         uint32_t _ptr_description;
5929         TALLOC_CTX *_mem_save_description_0;
5930         uint32_t _ptr_comment;
5931         TALLOC_CTX *_mem_save_comment_0;
5932         if (ndr_flags & NDR_SCALARS) {
5933                 NDR_CHECK(ndr_pull_align(ndr, 4));
5934                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5936                 if (_ptr_name) {
5937                         NDR_PULL_ALLOC(ndr, r->name);
5938                 } else {
5939                         r->name = NULL;
5940                 }
5941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5942                 if (_ptr_description) {
5943                         NDR_PULL_ALLOC(ndr, r->description);
5944                 } else {
5945                         r->description = NULL;
5946                 }
5947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5948                 if (_ptr_comment) {
5949                         NDR_PULL_ALLOC(ndr, r->comment);
5950                 } else {
5951                         r->comment = NULL;
5952                 }
5953         }
5954         if (ndr_flags & NDR_BUFFERS) {
5955                 if (r->name) {
5956                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
5960                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->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->name), ndr_get_array_length(ndr, &r->name));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
5966                 }
5967                 if (r->description) {
5968                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
5972                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
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->description), ndr_get_array_length(ndr, &r->description));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
5978                 }
5979                 if (r->comment) {
5980                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5984                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
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->comment), ndr_get_array_length(ndr, &r->comment));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5990                 }
5991         }
5992         return NDR_ERR_SUCCESS;
5993 }
5994
5995 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
5996 {
5997         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
5998         ndr->depth++;
5999         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6000         ndr_print_ptr(ndr, "name", r->name);
6001         ndr->depth++;
6002         if (r->name) {
6003                 ndr_print_string(ndr, "name", r->name);
6004         }
6005         ndr->depth--;
6006         ndr_print_ptr(ndr, "description", r->description);
6007         ndr->depth++;
6008         if (r->description) {
6009                 ndr_print_string(ndr, "description", r->description);
6010         }
6011         ndr->depth--;
6012         ndr_print_ptr(ndr, "comment", r->comment);
6013         ndr->depth++;
6014         if (r->comment) {
6015                 ndr_print_string(ndr, "comment", r->comment);
6016         }
6017         ndr->depth--;
6018         ndr->depth--;
6019 }
6020
6021 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6022 {
6023         if (ndr_flags & NDR_SCALARS) {
6024                 NDR_CHECK(ndr_push_align(ndr, 4));
6025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6038                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6043                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6046         }
6047         if (ndr_flags & NDR_BUFFERS) {
6048                 if (r->servername) {
6049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6053                 }
6054                 if (r->printername) {
6055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6058                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6059                 }
6060                 if (r->sharename) {
6061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6064                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6065                 }
6066                 if (r->portname) {
6067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6071                 }
6072                 if (r->drivername) {
6073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6077                 }
6078                 if (r->comment) {
6079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6083                 }
6084                 if (r->location) {
6085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6088                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6089                 }
6090                 if (r->devmode) {
6091                         {
6092                                 struct ndr_push *_ndr_devmode;
6093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6096                         }
6097                 }
6098                 if (r->sepfile) {
6099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6103                 }
6104                 if (r->printprocessor) {
6105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6109                 }
6110                 if (r->datatype) {
6111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6115                 }
6116                 if (r->parameters) {
6117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6121                 }
6122                 if (r->secdesc) {
6123                         {
6124                                 struct ndr_push *_ndr_secdesc;
6125                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6126                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6127                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6128                         }
6129                 }
6130         }
6131         return NDR_ERR_SUCCESS;
6132 }
6133
6134 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6135 {
6136         uint32_t _ptr_servername;
6137         TALLOC_CTX *_mem_save_servername_0;
6138         uint32_t _ptr_printername;
6139         TALLOC_CTX *_mem_save_printername_0;
6140         uint32_t _ptr_sharename;
6141         TALLOC_CTX *_mem_save_sharename_0;
6142         uint32_t _ptr_portname;
6143         TALLOC_CTX *_mem_save_portname_0;
6144         uint32_t _ptr_drivername;
6145         TALLOC_CTX *_mem_save_drivername_0;
6146         uint32_t _ptr_comment;
6147         TALLOC_CTX *_mem_save_comment_0;
6148         uint32_t _ptr_location;
6149         TALLOC_CTX *_mem_save_location_0;
6150         uint32_t _ptr_devmode;
6151         TALLOC_CTX *_mem_save_devmode_0;
6152         uint32_t _ptr_sepfile;
6153         TALLOC_CTX *_mem_save_sepfile_0;
6154         uint32_t _ptr_printprocessor;
6155         TALLOC_CTX *_mem_save_printprocessor_0;
6156         uint32_t _ptr_datatype;
6157         TALLOC_CTX *_mem_save_datatype_0;
6158         uint32_t _ptr_parameters;
6159         TALLOC_CTX *_mem_save_parameters_0;
6160         uint32_t _ptr_secdesc;
6161         TALLOC_CTX *_mem_save_secdesc_0;
6162         if (ndr_flags & NDR_SCALARS) {
6163                 NDR_CHECK(ndr_pull_align(ndr, 4));
6164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6165                 if (_ptr_servername) {
6166                         NDR_PULL_ALLOC(ndr, r->servername);
6167                 } else {
6168                         r->servername = NULL;
6169                 }
6170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6171                 if (_ptr_printername) {
6172                         NDR_PULL_ALLOC(ndr, r->printername);
6173                 } else {
6174                         r->printername = NULL;
6175                 }
6176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6177                 if (_ptr_sharename) {
6178                         NDR_PULL_ALLOC(ndr, r->sharename);
6179                 } else {
6180                         r->sharename = NULL;
6181                 }
6182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6183                 if (_ptr_portname) {
6184                         NDR_PULL_ALLOC(ndr, r->portname);
6185                 } else {
6186                         r->portname = NULL;
6187                 }
6188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6189                 if (_ptr_drivername) {
6190                         NDR_PULL_ALLOC(ndr, r->drivername);
6191                 } else {
6192                         r->drivername = NULL;
6193                 }
6194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6195                 if (_ptr_comment) {
6196                         NDR_PULL_ALLOC(ndr, r->comment);
6197                 } else {
6198                         r->comment = NULL;
6199                 }
6200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6201                 if (_ptr_location) {
6202                         NDR_PULL_ALLOC(ndr, r->location);
6203                 } else {
6204                         r->location = NULL;
6205                 }
6206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6207                 if (_ptr_devmode) {
6208                         NDR_PULL_ALLOC(ndr, r->devmode);
6209                 } else {
6210                         r->devmode = NULL;
6211                 }
6212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6213                 if (_ptr_sepfile) {
6214                         NDR_PULL_ALLOC(ndr, r->sepfile);
6215                 } else {
6216                         r->sepfile = NULL;
6217                 }
6218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6219                 if (_ptr_printprocessor) {
6220                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6221                 } else {
6222                         r->printprocessor = NULL;
6223                 }
6224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6225                 if (_ptr_datatype) {
6226                         NDR_PULL_ALLOC(ndr, r->datatype);
6227                 } else {
6228                         r->datatype = NULL;
6229                 }
6230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6231                 if (_ptr_parameters) {
6232                         NDR_PULL_ALLOC(ndr, r->parameters);
6233                 } else {
6234                         r->parameters = NULL;
6235                 }
6236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6237                 if (_ptr_secdesc) {
6238                         NDR_PULL_ALLOC(ndr, r->secdesc);
6239                 } else {
6240                         r->secdesc = NULL;
6241                 }
6242                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6247                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6250         }
6251         if (ndr_flags & NDR_BUFFERS) {
6252                 if (r->servername) {
6253                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6254                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6255                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6256                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6257                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6258                                 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));
6259                         }
6260                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6261                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6263                 }
6264                 if (r->printername) {
6265                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6266                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6269                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6270                                 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));
6271                         }
6272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6275                 }
6276                 if (r->sharename) {
6277                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6278                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6281                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6282                                 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));
6283                         }
6284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6285                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6287                 }
6288                 if (r->portname) {
6289                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6290                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6293                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6294                                 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));
6295                         }
6296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6299                 }
6300                 if (r->drivername) {
6301                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6302                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6305                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6306                                 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));
6307                         }
6308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6309                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6311                 }
6312                 if (r->comment) {
6313                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6314                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6317                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6318                                 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));
6319                         }
6320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6323                 }
6324                 if (r->location) {
6325                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6326                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6329                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6330                                 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));
6331                         }
6332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6335                 }
6336                 if (r->devmode) {
6337                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6338                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6339                         {
6340                                 struct ndr_pull *_ndr_devmode;
6341                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6342                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6343                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6344                         }
6345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6346                 }
6347                 if (r->sepfile) {
6348                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6349                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6350                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6351                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6352                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6353                                 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));
6354                         }
6355                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6356                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6358                 }
6359                 if (r->printprocessor) {
6360                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6361                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6364                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6365                                 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));
6366                         }
6367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6370                 }
6371                 if (r->datatype) {
6372                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6373                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6374                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6375                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6376                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6377                                 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));
6378                         }
6379                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6380                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6382                 }
6383                 if (r->parameters) {
6384                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6385                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6388                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6389                                 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));
6390                         }
6391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6394                 }
6395                 if (r->secdesc) {
6396                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6397                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6398                         {
6399                                 struct ndr_pull *_ndr_secdesc;
6400                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6401                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6402                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6403                         }
6404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6405                 }
6406         }
6407         return NDR_ERR_SUCCESS;
6408 }
6409
6410 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6411 {
6412         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6413         ndr->depth++;
6414         ndr_print_ptr(ndr, "servername", r->servername);
6415         ndr->depth++;
6416         if (r->servername) {
6417                 ndr_print_string(ndr, "servername", r->servername);
6418         }
6419         ndr->depth--;
6420         ndr_print_ptr(ndr, "printername", r->printername);
6421         ndr->depth++;
6422         if (r->printername) {
6423                 ndr_print_string(ndr, "printername", r->printername);
6424         }
6425         ndr->depth--;
6426         ndr_print_ptr(ndr, "sharename", r->sharename);
6427         ndr->depth++;
6428         if (r->sharename) {
6429                 ndr_print_string(ndr, "sharename", r->sharename);
6430         }
6431         ndr->depth--;
6432         ndr_print_ptr(ndr, "portname", r->portname);
6433         ndr->depth++;
6434         if (r->portname) {
6435                 ndr_print_string(ndr, "portname", r->portname);
6436         }
6437         ndr->depth--;
6438         ndr_print_ptr(ndr, "drivername", r->drivername);
6439         ndr->depth++;
6440         if (r->drivername) {
6441                 ndr_print_string(ndr, "drivername", r->drivername);
6442         }
6443         ndr->depth--;
6444         ndr_print_ptr(ndr, "comment", r->comment);
6445         ndr->depth++;
6446         if (r->comment) {
6447                 ndr_print_string(ndr, "comment", r->comment);
6448         }
6449         ndr->depth--;
6450         ndr_print_ptr(ndr, "location", r->location);
6451         ndr->depth++;
6452         if (r->location) {
6453                 ndr_print_string(ndr, "location", r->location);
6454         }
6455         ndr->depth--;
6456         ndr_print_ptr(ndr, "devmode", r->devmode);
6457         ndr->depth++;
6458         if (r->devmode) {
6459                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6460         }
6461         ndr->depth--;
6462         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6463         ndr->depth++;
6464         if (r->sepfile) {
6465                 ndr_print_string(ndr, "sepfile", r->sepfile);
6466         }
6467         ndr->depth--;
6468         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6469         ndr->depth++;
6470         if (r->printprocessor) {
6471                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6472         }
6473         ndr->depth--;
6474         ndr_print_ptr(ndr, "datatype", r->datatype);
6475         ndr->depth++;
6476         if (r->datatype) {
6477                 ndr_print_string(ndr, "datatype", r->datatype);
6478         }
6479         ndr->depth--;
6480         ndr_print_ptr(ndr, "parameters", r->parameters);
6481         ndr->depth++;
6482         if (r->parameters) {
6483                 ndr_print_string(ndr, "parameters", r->parameters);
6484         }
6485         ndr->depth--;
6486         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6487         ndr->depth++;
6488         if (r->secdesc) {
6489                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6490         }
6491         ndr->depth--;
6492         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6493         ndr_print_uint32(ndr, "priority", r->priority);
6494         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6495         ndr_print_uint32(ndr, "starttime", r->starttime);
6496         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6497         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6498         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6499         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6500         ndr->depth--;
6501 }
6502
6503 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6504 {
6505         if (ndr_flags & NDR_SCALARS) {
6506                 NDR_CHECK(ndr_push_align(ndr, 4));
6507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6508         }
6509         if (ndr_flags & NDR_BUFFERS) {
6510         }
6511         return NDR_ERR_SUCCESS;
6512 }
6513
6514 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6515 {
6516         if (ndr_flags & NDR_SCALARS) {
6517                 NDR_CHECK(ndr_pull_align(ndr, 4));
6518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6519         }
6520         if (ndr_flags & NDR_BUFFERS) {
6521         }
6522         return NDR_ERR_SUCCESS;
6523 }
6524
6525 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6526 {
6527         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6528         ndr->depth++;
6529         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6530         ndr->depth--;
6531 }
6532
6533 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6534 {
6535         if (ndr_flags & NDR_SCALARS) {
6536                 NDR_CHECK(ndr_push_align(ndr, 4));
6537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6539                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6540         }
6541         if (ndr_flags & NDR_BUFFERS) {
6542                 if (r->printername) {
6543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6546                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6547                 }
6548                 if (r->servername) {
6549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6552                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6553                 }
6554         }
6555         return NDR_ERR_SUCCESS;
6556 }
6557
6558 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6559 {
6560         uint32_t _ptr_printername;
6561         TALLOC_CTX *_mem_save_printername_0;
6562         uint32_t _ptr_servername;
6563         TALLOC_CTX *_mem_save_servername_0;
6564         if (ndr_flags & NDR_SCALARS) {
6565                 NDR_CHECK(ndr_pull_align(ndr, 4));
6566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6567                 if (_ptr_printername) {
6568                         NDR_PULL_ALLOC(ndr, r->printername);
6569                 } else {
6570                         r->printername = NULL;
6571                 }
6572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6573                 if (_ptr_servername) {
6574                         NDR_PULL_ALLOC(ndr, r->servername);
6575                 } else {
6576                         r->servername = NULL;
6577                 }
6578                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6579         }
6580         if (ndr_flags & NDR_BUFFERS) {
6581                 if (r->printername) {
6582                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6583                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6586                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6587                                 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));
6588                         }
6589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6592                 }
6593                 if (r->servername) {
6594                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6595                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6598                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6599                                 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));
6600                         }
6601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6604                 }
6605         }
6606         return NDR_ERR_SUCCESS;
6607 }
6608
6609 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6610 {
6611         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6612         ndr->depth++;
6613         ndr_print_ptr(ndr, "printername", r->printername);
6614         ndr->depth++;
6615         if (r->printername) {
6616                 ndr_print_string(ndr, "printername", r->printername);
6617         }
6618         ndr->depth--;
6619         ndr_print_ptr(ndr, "servername", r->servername);
6620         ndr->depth++;
6621         if (r->servername) {
6622                 ndr_print_string(ndr, "servername", r->servername);
6623         }
6624         ndr->depth--;
6625         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6626         ndr->depth--;
6627 }
6628
6629 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6630 {
6631         if (ndr_flags & NDR_SCALARS) {
6632                 NDR_CHECK(ndr_push_align(ndr, 4));
6633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6635                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6638         }
6639         if (ndr_flags & NDR_BUFFERS) {
6640                 if (r->printername) {
6641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6644                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6645                 }
6646                 if (r->portname) {
6647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6651                 }
6652         }
6653         return NDR_ERR_SUCCESS;
6654 }
6655
6656 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6657 {
6658         uint32_t _ptr_printername;
6659         TALLOC_CTX *_mem_save_printername_0;
6660         uint32_t _ptr_portname;
6661         TALLOC_CTX *_mem_save_portname_0;
6662         if (ndr_flags & NDR_SCALARS) {
6663                 NDR_CHECK(ndr_pull_align(ndr, 4));
6664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6665                 if (_ptr_printername) {
6666                         NDR_PULL_ALLOC(ndr, r->printername);
6667                 } else {
6668                         r->printername = NULL;
6669                 }
6670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6671                 if (_ptr_portname) {
6672                         NDR_PULL_ALLOC(ndr, r->portname);
6673                 } else {
6674                         r->portname = NULL;
6675                 }
6676                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6679         }
6680         if (ndr_flags & NDR_BUFFERS) {
6681                 if (r->printername) {
6682                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6683                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6686                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6687                                 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));
6688                         }
6689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6690                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6692                 }
6693                 if (r->portname) {
6694                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6695                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6698                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6699                                 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));
6700                         }
6701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6704                 }
6705         }
6706         return NDR_ERR_SUCCESS;
6707 }
6708
6709 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6710 {
6711         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6712         ndr->depth++;
6713         ndr_print_ptr(ndr, "printername", r->printername);
6714         ndr->depth++;
6715         if (r->printername) {
6716                 ndr_print_string(ndr, "printername", r->printername);
6717         }
6718         ndr->depth--;
6719         ndr_print_ptr(ndr, "portname", r->portname);
6720         ndr->depth++;
6721         if (r->portname) {
6722                 ndr_print_string(ndr, "portname", r->portname);
6723         }
6724         ndr->depth--;
6725         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6726         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6727         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6728         ndr->depth--;
6729 }
6730
6731 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6732 {
6733         if (ndr_flags & NDR_SCALARS) {
6734                 NDR_CHECK(ndr_push_align(ndr, 4));
6735                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6736         }
6737         if (ndr_flags & NDR_BUFFERS) {
6738         }
6739         return NDR_ERR_SUCCESS;
6740 }
6741
6742 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6743 {
6744         if (ndr_flags & NDR_SCALARS) {
6745                 NDR_CHECK(ndr_pull_align(ndr, 4));
6746                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6747         }
6748         if (ndr_flags & NDR_BUFFERS) {
6749         }
6750         return NDR_ERR_SUCCESS;
6751 }
6752
6753 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6754 {
6755         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6756         ndr->depth++;
6757         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6758         ndr->depth--;
6759 }
6760
6761 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6762 {
6763         if (ndr_flags & NDR_SCALARS) {
6764                 NDR_CHECK(ndr_push_align(ndr, 4));
6765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6766                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6767         }
6768         if (ndr_flags & NDR_BUFFERS) {
6769                 if (r->guid) {
6770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6774                 }
6775         }
6776         return NDR_ERR_SUCCESS;
6777 }
6778
6779 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6780 {
6781         uint32_t _ptr_guid;
6782         TALLOC_CTX *_mem_save_guid_0;
6783         if (ndr_flags & NDR_SCALARS) {
6784                 NDR_CHECK(ndr_pull_align(ndr, 4));
6785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6786                 if (_ptr_guid) {
6787                         NDR_PULL_ALLOC(ndr, r->guid);
6788                 } else {
6789                         r->guid = NULL;
6790                 }
6791                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6792         }
6793         if (ndr_flags & NDR_BUFFERS) {
6794                 if (r->guid) {
6795                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6796                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6799                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6800                                 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));
6801                         }
6802                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6803                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6805                 }
6806         }
6807         return NDR_ERR_SUCCESS;
6808 }
6809
6810 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6811 {
6812         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6813         ndr->depth++;
6814         ndr_print_ptr(ndr, "guid", r->guid);
6815         ndr->depth++;
6816         if (r->guid) {
6817                 ndr_print_string(ndr, "guid", r->guid);
6818         }
6819         ndr->depth--;
6820         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6821         ndr->depth--;
6822 }
6823
6824 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6825 {
6826         if (ndr_flags & NDR_SCALARS) {
6827                 int level = ndr_push_get_switch_value(ndr, r);
6828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6829                 switch (level) {
6830                         case 0: {
6831                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6832                         break; }
6833
6834                         case 1: {
6835                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6836                         break; }
6837
6838                         case 2: {
6839                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6840                         break; }
6841
6842                         case 3: {
6843                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6844                         break; }
6845
6846                         case 4: {
6847                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6848                         break; }
6849
6850                         case 5: {
6851                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6852                         break; }
6853
6854                         case 6: {
6855                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6856                         break; }
6857
6858                         case 7: {
6859                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6860                         break; }
6861
6862                         case 8: {
6863                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6864                         break; }
6865
6866                         case 9: {
6867                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6868                         break; }
6869
6870                         default: {
6871                         break; }
6872
6873                 }
6874         }
6875         if (ndr_flags & NDR_BUFFERS) {
6876                 int level = ndr_push_get_switch_value(ndr, r);
6877                 switch (level) {
6878                         case 0:
6879                                 if (r->info0) {
6880                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6881                                 }
6882                         break;
6883
6884                         case 1:
6885                                 if (r->info1) {
6886                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6887                                 }
6888                         break;
6889
6890                         case 2:
6891                                 if (r->info2) {
6892                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6893                                 }
6894                         break;
6895
6896                         case 3:
6897                                 if (r->info3) {
6898                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6899                                 }
6900                         break;
6901
6902                         case 4:
6903                                 if (r->info4) {
6904                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6905                                 }
6906                         break;
6907
6908                         case 5:
6909                                 if (r->info5) {
6910                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6911                                 }
6912                         break;
6913
6914                         case 6:
6915                                 if (r->info6) {
6916                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6917                                 }
6918                         break;
6919
6920                         case 7:
6921                                 if (r->info7) {
6922                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6923                                 }
6924                         break;
6925
6926                         case 8:
6927                                 if (r->info8) {
6928                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6929                                 }
6930                         break;
6931
6932                         case 9:
6933                                 if (r->info9) {
6934                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6935                                 }
6936                         break;
6937
6938                         default:
6939                         break;
6940
6941                 }
6942         }
6943         return NDR_ERR_SUCCESS;
6944 }
6945
6946 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6947 {
6948         int level;
6949         uint32_t _level;
6950         TALLOC_CTX *_mem_save_info0_0;
6951         TALLOC_CTX *_mem_save_info1_0;
6952         TALLOC_CTX *_mem_save_info2_0;
6953         TALLOC_CTX *_mem_save_info3_0;
6954         TALLOC_CTX *_mem_save_info4_0;
6955         TALLOC_CTX *_mem_save_info5_0;
6956         TALLOC_CTX *_mem_save_info6_0;
6957         TALLOC_CTX *_mem_save_info7_0;
6958         TALLOC_CTX *_mem_save_info8_0;
6959         TALLOC_CTX *_mem_save_info9_0;
6960         level = ndr_pull_get_switch_value(ndr, r);
6961         if (ndr_flags & NDR_SCALARS) {
6962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6963                 if (_level != level) {
6964                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6965                 }
6966                 switch (level) {
6967                         case 0: {
6968                                 uint32_t _ptr_info0;
6969                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
6970                                 if (_ptr_info0) {
6971                                         NDR_PULL_ALLOC(ndr, r->info0);
6972                                 } else {
6973                                         r->info0 = NULL;
6974                                 }
6975                         break; }
6976
6977                         case 1: {
6978                                 uint32_t _ptr_info1;
6979                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6980                                 if (_ptr_info1) {
6981                                         NDR_PULL_ALLOC(ndr, r->info1);
6982                                 } else {
6983                                         r->info1 = NULL;
6984                                 }
6985                         break; }
6986
6987                         case 2: {
6988                                 uint32_t _ptr_info2;
6989                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6990                                 if (_ptr_info2) {
6991                                         NDR_PULL_ALLOC(ndr, r->info2);
6992                                 } else {
6993                                         r->info2 = NULL;
6994                                 }
6995                         break; }
6996
6997                         case 3: {
6998                                 uint32_t _ptr_info3;
6999                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7000                                 if (_ptr_info3) {
7001                                         NDR_PULL_ALLOC(ndr, r->info3);
7002                                 } else {
7003                                         r->info3 = NULL;
7004                                 }
7005                         break; }
7006
7007                         case 4: {
7008                                 uint32_t _ptr_info4;
7009                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7010                                 if (_ptr_info4) {
7011                                         NDR_PULL_ALLOC(ndr, r->info4);
7012                                 } else {
7013                                         r->info4 = NULL;
7014                                 }
7015                         break; }
7016
7017                         case 5: {
7018                                 uint32_t _ptr_info5;
7019                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7020                                 if (_ptr_info5) {
7021                                         NDR_PULL_ALLOC(ndr, r->info5);
7022                                 } else {
7023                                         r->info5 = NULL;
7024                                 }
7025                         break; }
7026
7027                         case 6: {
7028                                 uint32_t _ptr_info6;
7029                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7030                                 if (_ptr_info6) {
7031                                         NDR_PULL_ALLOC(ndr, r->info6);
7032                                 } else {
7033                                         r->info6 = NULL;
7034                                 }
7035                         break; }
7036
7037                         case 7: {
7038                                 uint32_t _ptr_info7;
7039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7040                                 if (_ptr_info7) {
7041                                         NDR_PULL_ALLOC(ndr, r->info7);
7042                                 } else {
7043                                         r->info7 = NULL;
7044                                 }
7045                         break; }
7046
7047                         case 8: {
7048                                 uint32_t _ptr_info8;
7049                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7050                                 if (_ptr_info8) {
7051                                         NDR_PULL_ALLOC(ndr, r->info8);
7052                                 } else {
7053                                         r->info8 = NULL;
7054                                 }
7055                         break; }
7056
7057                         case 9: {
7058                                 uint32_t _ptr_info9;
7059                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7060                                 if (_ptr_info9) {
7061                                         NDR_PULL_ALLOC(ndr, r->info9);
7062                                 } else {
7063                                         r->info9 = NULL;
7064                                 }
7065                         break; }
7066
7067                         default: {
7068                         break; }
7069
7070                 }
7071         }
7072         if (ndr_flags & NDR_BUFFERS) {
7073                 switch (level) {
7074                         case 0:
7075                                 if (r->info0) {
7076                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7077                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7078                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7079                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7080                                 }
7081                         break;
7082
7083                         case 1:
7084                                 if (r->info1) {
7085                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7086                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7087                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7088                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7089                                 }
7090                         break;
7091
7092                         case 2:
7093                                 if (r->info2) {
7094                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7096                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7097                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7098                                 }
7099                         break;
7100
7101                         case 3:
7102                                 if (r->info3) {
7103                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7104                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7105                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7106                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7107                                 }
7108                         break;
7109
7110                         case 4:
7111                                 if (r->info4) {
7112                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7113                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7114                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7115                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7116                                 }
7117                         break;
7118
7119                         case 5:
7120                                 if (r->info5) {
7121                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7123                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7125                                 }
7126                         break;
7127
7128                         case 6:
7129                                 if (r->info6) {
7130                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7131                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7132                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7133                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7134                                 }
7135                         break;
7136
7137                         case 7:
7138                                 if (r->info7) {
7139                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7140                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7141                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7142                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7143                                 }
7144                         break;
7145
7146                         case 8:
7147                                 if (r->info8) {
7148                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7149                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7150                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7151                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7152                                 }
7153                         break;
7154
7155                         case 9:
7156                                 if (r->info9) {
7157                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7158                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7159                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7160                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7161                                 }
7162                         break;
7163
7164                         default:
7165                         break;
7166
7167                 }
7168         }
7169         return NDR_ERR_SUCCESS;
7170 }
7171
7172 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7173 {
7174         int level;
7175         level = ndr_print_get_switch_value(ndr, r);
7176         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7177         switch (level) {
7178                 case 0:
7179                         ndr_print_ptr(ndr, "info0", r->info0);
7180                         ndr->depth++;
7181                         if (r->info0) {
7182                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7183                         }
7184                         ndr->depth--;
7185                 break;
7186
7187                 case 1:
7188                         ndr_print_ptr(ndr, "info1", r->info1);
7189                         ndr->depth++;
7190                         if (r->info1) {
7191                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7192                         }
7193                         ndr->depth--;
7194                 break;
7195
7196                 case 2:
7197                         ndr_print_ptr(ndr, "info2", r->info2);
7198                         ndr->depth++;
7199                         if (r->info2) {
7200                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7201                         }
7202                         ndr->depth--;
7203                 break;
7204
7205                 case 3:
7206                         ndr_print_ptr(ndr, "info3", r->info3);
7207                         ndr->depth++;
7208                         if (r->info3) {
7209                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7210                         }
7211                         ndr->depth--;
7212                 break;
7213
7214                 case 4:
7215                         ndr_print_ptr(ndr, "info4", r->info4);
7216                         ndr->depth++;
7217                         if (r->info4) {
7218                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7219                         }
7220                         ndr->depth--;
7221                 break;
7222
7223                 case 5:
7224                         ndr_print_ptr(ndr, "info5", r->info5);
7225                         ndr->depth++;
7226                         if (r->info5) {
7227                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7228                         }
7229                         ndr->depth--;
7230                 break;
7231
7232                 case 6:
7233                         ndr_print_ptr(ndr, "info6", r->info6);
7234                         ndr->depth++;
7235                         if (r->info6) {
7236                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7237                         }
7238                         ndr->depth--;
7239                 break;
7240
7241                 case 7:
7242                         ndr_print_ptr(ndr, "info7", r->info7);
7243                         ndr->depth++;
7244                         if (r->info7) {
7245                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7246                         }
7247                         ndr->depth--;
7248                 break;
7249
7250                 case 8:
7251                         ndr_print_ptr(ndr, "info8", r->info8);
7252                         ndr->depth++;
7253                         if (r->info8) {
7254                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7255                         }
7256                         ndr->depth--;
7257                 break;
7258
7259                 case 9:
7260                         ndr_print_ptr(ndr, "info9", r->info9);
7261                         ndr->depth++;
7262                         if (r->info9) {
7263                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7264                         }
7265                         ndr->depth--;
7266                 break;
7267
7268                 default:
7269                 break;
7270
7271         }
7272 }
7273
7274 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7275 {
7276         if (ndr_flags & NDR_SCALARS) {
7277                 NDR_CHECK(ndr_push_align(ndr, 4));
7278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7279                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7280                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7281         }
7282         if (ndr_flags & NDR_BUFFERS) {
7283                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7284         }
7285         return NDR_ERR_SUCCESS;
7286 }
7287
7288 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7289 {
7290         if (ndr_flags & NDR_SCALARS) {
7291                 NDR_CHECK(ndr_pull_align(ndr, 4));
7292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7293                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7294                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7295         }
7296         if (ndr_flags & NDR_BUFFERS) {
7297                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7298         }
7299         return NDR_ERR_SUCCESS;
7300 }
7301
7302 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7303 {
7304         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7305         ndr->depth++;
7306         ndr_print_uint32(ndr, "level", r->level);
7307         ndr_print_set_switch_value(ndr, &r->info, r->level);
7308         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7309         ndr->depth--;
7310 }
7311
7312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7313 {
7314         if (ndr_flags & NDR_SCALARS) {
7315                 NDR_CHECK(ndr_push_align(ndr, 4));
7316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7317                 {
7318                         uint32_t _flags_save_string_array = ndr->flags;
7319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7320                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7321                         ndr->flags = _flags_save_string_array;
7322                 }
7323         }
7324         if (ndr_flags & NDR_BUFFERS) {
7325         }
7326         return NDR_ERR_SUCCESS;
7327 }
7328
7329 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7330 {
7331         if (ndr_flags & NDR_SCALARS) {
7332                 NDR_CHECK(ndr_pull_align(ndr, 4));
7333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7334                 {
7335                         uint32_t _flags_save_string_array = ndr->flags;
7336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7337                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7338                         ndr->flags = _flags_save_string_array;
7339                 }
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342         }
7343         return NDR_ERR_SUCCESS;
7344 }
7345
7346 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7347 {
7348         ndr_print_struct(ndr, name, "spoolss_StringArray");
7349         ndr->depth++;
7350         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);
7351         ndr_print_string_array(ndr, "string", r->string);
7352         ndr->depth--;
7353 }
7354
7355 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7356 {
7357         if (ndr_flags & NDR_SCALARS) {
7358                 NDR_CHECK(ndr_push_align(ndr, 4));
7359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7360         }
7361         if (ndr_flags & NDR_BUFFERS) {
7362                 if (r->driver_name) {
7363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7367                 }
7368         }
7369         return NDR_ERR_SUCCESS;
7370 }
7371
7372 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7373 {
7374         uint32_t _ptr_driver_name;
7375         TALLOC_CTX *_mem_save_driver_name_0;
7376         if (ndr_flags & NDR_SCALARS) {
7377                 NDR_CHECK(ndr_pull_align(ndr, 4));
7378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7379                 if (_ptr_driver_name) {
7380                         NDR_PULL_ALLOC(ndr, r->driver_name);
7381                 } else {
7382                         r->driver_name = NULL;
7383                 }
7384         }
7385         if (ndr_flags & NDR_BUFFERS) {
7386                 if (r->driver_name) {
7387                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7388                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7391                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7392                                 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));
7393                         }
7394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7397                 }
7398         }
7399         return NDR_ERR_SUCCESS;
7400 }
7401
7402 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7403 {
7404         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7405         ndr->depth++;
7406         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7407         ndr->depth++;
7408         if (r->driver_name) {
7409                 ndr_print_string(ndr, "driver_name", r->driver_name);
7410         }
7411         ndr->depth--;
7412         ndr->depth--;
7413 }
7414
7415 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7416 {
7417         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7418         return NDR_ERR_SUCCESS;
7419 }
7420
7421 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7422 {
7423         uint32_t v;
7424         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7425         *r = v;
7426         return NDR_ERR_SUCCESS;
7427 }
7428
7429 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7430 {
7431         const char *val = NULL;
7432
7433         switch (r) {
7434                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7435                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7436                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7437                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7438         }
7439         ndr_print_enum(ndr, name, "ENUM", val, r);
7440 }
7441
7442 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7443 {
7444         if (ndr_flags & NDR_SCALARS) {
7445                 NDR_CHECK(ndr_push_align(ndr, 4));
7446                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7452         }
7453         if (ndr_flags & NDR_BUFFERS) {
7454                 if (r->driver_name) {
7455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7459                 }
7460                 if (r->architecture) {
7461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7465                 }
7466                 if (r->driver_path) {
7467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7471                 }
7472                 if (r->data_file) {
7473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7477                 }
7478                 if (r->config_file) {
7479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7482                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7483                 }
7484         }
7485         return NDR_ERR_SUCCESS;
7486 }
7487
7488 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7489 {
7490         uint32_t _ptr_driver_name;
7491         TALLOC_CTX *_mem_save_driver_name_0;
7492         uint32_t _ptr_architecture;
7493         TALLOC_CTX *_mem_save_architecture_0;
7494         uint32_t _ptr_driver_path;
7495         TALLOC_CTX *_mem_save_driver_path_0;
7496         uint32_t _ptr_data_file;
7497         TALLOC_CTX *_mem_save_data_file_0;
7498         uint32_t _ptr_config_file;
7499         TALLOC_CTX *_mem_save_config_file_0;
7500         if (ndr_flags & NDR_SCALARS) {
7501                 NDR_CHECK(ndr_pull_align(ndr, 4));
7502                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7504                 if (_ptr_driver_name) {
7505                         NDR_PULL_ALLOC(ndr, r->driver_name);
7506                 } else {
7507                         r->driver_name = NULL;
7508                 }
7509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7510                 if (_ptr_architecture) {
7511                         NDR_PULL_ALLOC(ndr, r->architecture);
7512                 } else {
7513                         r->architecture = NULL;
7514                 }
7515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7516                 if (_ptr_driver_path) {
7517                         NDR_PULL_ALLOC(ndr, r->driver_path);
7518                 } else {
7519                         r->driver_path = NULL;
7520                 }
7521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7522                 if (_ptr_data_file) {
7523                         NDR_PULL_ALLOC(ndr, r->data_file);
7524                 } else {
7525                         r->data_file = NULL;
7526                 }
7527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7528                 if (_ptr_config_file) {
7529                         NDR_PULL_ALLOC(ndr, r->config_file);
7530                 } else {
7531                         r->config_file = NULL;
7532                 }
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->driver_name) {
7536                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7537                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7540                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7541                                 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));
7542                         }
7543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7546                 }
7547                 if (r->architecture) {
7548                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7549                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7552                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7553                                 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));
7554                         }
7555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7558                 }
7559                 if (r->driver_path) {
7560                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7561                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7564                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7565                                 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));
7566                         }
7567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7570                 }
7571                 if (r->data_file) {
7572                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7573                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7576                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7577                                 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));
7578                         }
7579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7582                 }
7583                 if (r->config_file) {
7584                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7585                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7588                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7589                                 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));
7590                         }
7591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7594                 }
7595         }
7596         return NDR_ERR_SUCCESS;
7597 }
7598
7599 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7600 {
7601         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7602         ndr->depth++;
7603         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7604         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7605         ndr->depth++;
7606         if (r->driver_name) {
7607                 ndr_print_string(ndr, "driver_name", r->driver_name);
7608         }
7609         ndr->depth--;
7610         ndr_print_ptr(ndr, "architecture", r->architecture);
7611         ndr->depth++;
7612         if (r->architecture) {
7613                 ndr_print_string(ndr, "architecture", r->architecture);
7614         }
7615         ndr->depth--;
7616         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7617         ndr->depth++;
7618         if (r->driver_path) {
7619                 ndr_print_string(ndr, "driver_path", r->driver_path);
7620         }
7621         ndr->depth--;
7622         ndr_print_ptr(ndr, "data_file", r->data_file);
7623         ndr->depth++;
7624         if (r->data_file) {
7625                 ndr_print_string(ndr, "data_file", r->data_file);
7626         }
7627         ndr->depth--;
7628         ndr_print_ptr(ndr, "config_file", r->config_file);
7629         ndr->depth++;
7630         if (r->config_file) {
7631                 ndr_print_string(ndr, "config_file", r->config_file);
7632         }
7633         ndr->depth--;
7634         ndr->depth--;
7635 }
7636
7637 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7638 {
7639         if (ndr_flags & NDR_SCALARS) {
7640                 NDR_CHECK(ndr_push_align(ndr, 4));
7641                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7652         }
7653         if (ndr_flags & NDR_BUFFERS) {
7654                 if (r->driver_name) {
7655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7659                 }
7660                 if (r->architecture) {
7661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7665                 }
7666                 if (r->driver_path) {
7667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7671                 }
7672                 if (r->data_file) {
7673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7677                 }
7678                 if (r->config_file) {
7679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7683                 }
7684                 if (r->help_file) {
7685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7689                 }
7690                 if (r->monitor_name) {
7691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7695                 }
7696                 if (r->default_datatype) {
7697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7701                 }
7702                 if (r->dependent_files) {
7703                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7704                 }
7705         }
7706         return NDR_ERR_SUCCESS;
7707 }
7708
7709 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7710 {
7711         uint32_t _ptr_driver_name;
7712         TALLOC_CTX *_mem_save_driver_name_0;
7713         uint32_t _ptr_architecture;
7714         TALLOC_CTX *_mem_save_architecture_0;
7715         uint32_t _ptr_driver_path;
7716         TALLOC_CTX *_mem_save_driver_path_0;
7717         uint32_t _ptr_data_file;
7718         TALLOC_CTX *_mem_save_data_file_0;
7719         uint32_t _ptr_config_file;
7720         TALLOC_CTX *_mem_save_config_file_0;
7721         uint32_t _ptr_help_file;
7722         TALLOC_CTX *_mem_save_help_file_0;
7723         uint32_t _ptr_monitor_name;
7724         TALLOC_CTX *_mem_save_monitor_name_0;
7725         uint32_t _ptr_default_datatype;
7726         TALLOC_CTX *_mem_save_default_datatype_0;
7727         uint32_t _ptr_dependent_files;
7728         TALLOC_CTX *_mem_save_dependent_files_0;
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_align(ndr, 4));
7731                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7733                 if (_ptr_driver_name) {
7734                         NDR_PULL_ALLOC(ndr, r->driver_name);
7735                 } else {
7736                         r->driver_name = NULL;
7737                 }
7738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7739                 if (_ptr_architecture) {
7740                         NDR_PULL_ALLOC(ndr, r->architecture);
7741                 } else {
7742                         r->architecture = NULL;
7743                 }
7744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7745                 if (_ptr_driver_path) {
7746                         NDR_PULL_ALLOC(ndr, r->driver_path);
7747                 } else {
7748                         r->driver_path = NULL;
7749                 }
7750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7751                 if (_ptr_data_file) {
7752                         NDR_PULL_ALLOC(ndr, r->data_file);
7753                 } else {
7754                         r->data_file = NULL;
7755                 }
7756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7757                 if (_ptr_config_file) {
7758                         NDR_PULL_ALLOC(ndr, r->config_file);
7759                 } else {
7760                         r->config_file = NULL;
7761                 }
7762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7763                 if (_ptr_help_file) {
7764                         NDR_PULL_ALLOC(ndr, r->help_file);
7765                 } else {
7766                         r->help_file = NULL;
7767                 }
7768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7769                 if (_ptr_monitor_name) {
7770                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7771                 } else {
7772                         r->monitor_name = NULL;
7773                 }
7774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7775                 if (_ptr_default_datatype) {
7776                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7777                 } else {
7778                         r->default_datatype = NULL;
7779                 }
7780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7782                 if (_ptr_dependent_files) {
7783                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7784                 } else {
7785                         r->dependent_files = NULL;
7786                 }
7787         }
7788         if (ndr_flags & NDR_BUFFERS) {
7789                 if (r->driver_name) {
7790                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7791                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7794                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7795                                 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));
7796                         }
7797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7800                 }
7801                 if (r->architecture) {
7802                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7803                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7806                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7807                                 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));
7808                         }
7809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7812                 }
7813                 if (r->driver_path) {
7814                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7815                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7818                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7819                                 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));
7820                         }
7821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7824                 }
7825                 if (r->data_file) {
7826                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7827                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7830                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7831                                 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));
7832                         }
7833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7836                 }
7837                 if (r->config_file) {
7838                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7839                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7842                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7843                                 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));
7844                         }
7845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7848                 }
7849                 if (r->help_file) {
7850                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7851                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7854                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7855                                 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));
7856                         }
7857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7860                 }
7861                 if (r->monitor_name) {
7862                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7863                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7866                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7867                                 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));
7868                         }
7869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7872                 }
7873                 if (r->default_datatype) {
7874                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7878                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7879                                 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));
7880                         }
7881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7884                 }
7885                 if (r->dependent_files) {
7886                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7887                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7888                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7890                 }
7891         }
7892         return NDR_ERR_SUCCESS;
7893 }
7894
7895 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7896 {
7897         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7898         ndr->depth++;
7899         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7900         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7901         ndr->depth++;
7902         if (r->driver_name) {
7903                 ndr_print_string(ndr, "driver_name", r->driver_name);
7904         }
7905         ndr->depth--;
7906         ndr_print_ptr(ndr, "architecture", r->architecture);
7907         ndr->depth++;
7908         if (r->architecture) {
7909                 ndr_print_string(ndr, "architecture", r->architecture);
7910         }
7911         ndr->depth--;
7912         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7913         ndr->depth++;
7914         if (r->driver_path) {
7915                 ndr_print_string(ndr, "driver_path", r->driver_path);
7916         }
7917         ndr->depth--;
7918         ndr_print_ptr(ndr, "data_file", r->data_file);
7919         ndr->depth++;
7920         if (r->data_file) {
7921                 ndr_print_string(ndr, "data_file", r->data_file);
7922         }
7923         ndr->depth--;
7924         ndr_print_ptr(ndr, "config_file", r->config_file);
7925         ndr->depth++;
7926         if (r->config_file) {
7927                 ndr_print_string(ndr, "config_file", r->config_file);
7928         }
7929         ndr->depth--;
7930         ndr_print_ptr(ndr, "help_file", r->help_file);
7931         ndr->depth++;
7932         if (r->help_file) {
7933                 ndr_print_string(ndr, "help_file", r->help_file);
7934         }
7935         ndr->depth--;
7936         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7937         ndr->depth++;
7938         if (r->monitor_name) {
7939                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7940         }
7941         ndr->depth--;
7942         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7943         ndr->depth++;
7944         if (r->default_datatype) {
7945                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7946         }
7947         ndr->depth--;
7948         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);
7949         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7950         ndr->depth++;
7951         if (r->dependent_files) {
7952                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7953         }
7954         ndr->depth--;
7955         ndr->depth--;
7956 }
7957
7958 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
7959 {
7960         if (ndr_flags & NDR_SCALARS) {
7961                 NDR_CHECK(ndr_push_align(ndr, 4));
7962                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7975         }
7976         if (ndr_flags & NDR_BUFFERS) {
7977                 if (r->driver_name) {
7978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7982                 }
7983                 if (r->architecture) {
7984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7987                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7988                 }
7989                 if (r->driver_path) {
7990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7994                 }
7995                 if (r->data_file) {
7996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7999                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8000                 }
8001                 if (r->config_file) {
8002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8006                 }
8007                 if (r->help_file) {
8008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8011                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8012                 }
8013                 if (r->monitor_name) {
8014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8018                 }
8019                 if (r->default_datatype) {
8020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8023                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8024                 }
8025                 if (r->dependent_files) {
8026                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8027                 }
8028                 if (r->previous_names) {
8029                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8030                 }
8031         }
8032         return NDR_ERR_SUCCESS;
8033 }
8034
8035 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8036 {
8037         uint32_t _ptr_driver_name;
8038         TALLOC_CTX *_mem_save_driver_name_0;
8039         uint32_t _ptr_architecture;
8040         TALLOC_CTX *_mem_save_architecture_0;
8041         uint32_t _ptr_driver_path;
8042         TALLOC_CTX *_mem_save_driver_path_0;
8043         uint32_t _ptr_data_file;
8044         TALLOC_CTX *_mem_save_data_file_0;
8045         uint32_t _ptr_config_file;
8046         TALLOC_CTX *_mem_save_config_file_0;
8047         uint32_t _ptr_help_file;
8048         TALLOC_CTX *_mem_save_help_file_0;
8049         uint32_t _ptr_monitor_name;
8050         TALLOC_CTX *_mem_save_monitor_name_0;
8051         uint32_t _ptr_default_datatype;
8052         TALLOC_CTX *_mem_save_default_datatype_0;
8053         uint32_t _ptr_dependent_files;
8054         TALLOC_CTX *_mem_save_dependent_files_0;
8055         uint32_t _ptr_previous_names;
8056         TALLOC_CTX *_mem_save_previous_names_0;
8057         if (ndr_flags & NDR_SCALARS) {
8058                 NDR_CHECK(ndr_pull_align(ndr, 4));
8059                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8061                 if (_ptr_driver_name) {
8062                         NDR_PULL_ALLOC(ndr, r->driver_name);
8063                 } else {
8064                         r->driver_name = NULL;
8065                 }
8066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8067                 if (_ptr_architecture) {
8068                         NDR_PULL_ALLOC(ndr, r->architecture);
8069                 } else {
8070                         r->architecture = NULL;
8071                 }
8072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8073                 if (_ptr_driver_path) {
8074                         NDR_PULL_ALLOC(ndr, r->driver_path);
8075                 } else {
8076                         r->driver_path = NULL;
8077                 }
8078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8079                 if (_ptr_data_file) {
8080                         NDR_PULL_ALLOC(ndr, r->data_file);
8081                 } else {
8082                         r->data_file = NULL;
8083                 }
8084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8085                 if (_ptr_config_file) {
8086                         NDR_PULL_ALLOC(ndr, r->config_file);
8087                 } else {
8088                         r->config_file = NULL;
8089                 }
8090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8091                 if (_ptr_help_file) {
8092                         NDR_PULL_ALLOC(ndr, r->help_file);
8093                 } else {
8094                         r->help_file = NULL;
8095                 }
8096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8097                 if (_ptr_monitor_name) {
8098                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8099                 } else {
8100                         r->monitor_name = NULL;
8101                 }
8102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8103                 if (_ptr_default_datatype) {
8104                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8105                 } else {
8106                         r->default_datatype = NULL;
8107                 }
8108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8110                 if (_ptr_dependent_files) {
8111                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8112                 } else {
8113                         r->dependent_files = NULL;
8114                 }
8115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8117                 if (_ptr_previous_names) {
8118                         NDR_PULL_ALLOC(ndr, r->previous_names);
8119                 } else {
8120                         r->previous_names = NULL;
8121                 }
8122         }
8123         if (ndr_flags & NDR_BUFFERS) {
8124                 if (r->driver_name) {
8125                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8126                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8127                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8128                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8129                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8130                                 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));
8131                         }
8132                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8133                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8135                 }
8136                 if (r->architecture) {
8137                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8138                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8141                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8142                                 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));
8143                         }
8144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8147                 }
8148                 if (r->driver_path) {
8149                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8150                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8153                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8154                                 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));
8155                         }
8156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8159                 }
8160                 if (r->data_file) {
8161                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8162                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8165                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8166                                 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));
8167                         }
8168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8171                 }
8172                 if (r->config_file) {
8173                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8174                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8177                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8178                                 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));
8179                         }
8180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8183                 }
8184                 if (r->help_file) {
8185                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8186                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8189                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8190                                 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));
8191                         }
8192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8195                 }
8196                 if (r->monitor_name) {
8197                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8198                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8201                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8202                                 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));
8203                         }
8204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8207                 }
8208                 if (r->default_datatype) {
8209                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8210                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8213                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8214                                 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));
8215                         }
8216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8219                 }
8220                 if (r->dependent_files) {
8221                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8222                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8223                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8225                 }
8226                 if (r->previous_names) {
8227                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8228                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8229                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8231                 }
8232         }
8233         return NDR_ERR_SUCCESS;
8234 }
8235
8236 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8237 {
8238         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8239         ndr->depth++;
8240         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8241         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8242         ndr->depth++;
8243         if (r->driver_name) {
8244                 ndr_print_string(ndr, "driver_name", r->driver_name);
8245         }
8246         ndr->depth--;
8247         ndr_print_ptr(ndr, "architecture", r->architecture);
8248         ndr->depth++;
8249         if (r->architecture) {
8250                 ndr_print_string(ndr, "architecture", r->architecture);
8251         }
8252         ndr->depth--;
8253         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8254         ndr->depth++;
8255         if (r->driver_path) {
8256                 ndr_print_string(ndr, "driver_path", r->driver_path);
8257         }
8258         ndr->depth--;
8259         ndr_print_ptr(ndr, "data_file", r->data_file);
8260         ndr->depth++;
8261         if (r->data_file) {
8262                 ndr_print_string(ndr, "data_file", r->data_file);
8263         }
8264         ndr->depth--;
8265         ndr_print_ptr(ndr, "config_file", r->config_file);
8266         ndr->depth++;
8267         if (r->config_file) {
8268                 ndr_print_string(ndr, "config_file", r->config_file);
8269         }
8270         ndr->depth--;
8271         ndr_print_ptr(ndr, "help_file", r->help_file);
8272         ndr->depth++;
8273         if (r->help_file) {
8274                 ndr_print_string(ndr, "help_file", r->help_file);
8275         }
8276         ndr->depth--;
8277         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8278         ndr->depth++;
8279         if (r->monitor_name) {
8280                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8281         }
8282         ndr->depth--;
8283         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8284         ndr->depth++;
8285         if (r->default_datatype) {
8286                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8287         }
8288         ndr->depth--;
8289         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);
8290         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8291         ndr->depth++;
8292         if (r->dependent_files) {
8293                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8294         }
8295         ndr->depth--;
8296         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);
8297         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8298         ndr->depth++;
8299         if (r->previous_names) {
8300                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8301         }
8302         ndr->depth--;
8303         ndr->depth--;
8304 }
8305
8306 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8307 {
8308         if (ndr_flags & NDR_SCALARS) {
8309                 NDR_CHECK(ndr_push_align(ndr, 8));
8310                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8314                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8323                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8324                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8329         }
8330         if (ndr_flags & NDR_BUFFERS) {
8331                 if (r->driver_name) {
8332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8335                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8336                 }
8337                 if (r->architecture) {
8338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8342                 }
8343                 if (r->driver_path) {
8344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8348                 }
8349                 if (r->data_file) {
8350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8353                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8354                 }
8355                 if (r->config_file) {
8356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8359                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8360                 }
8361                 if (r->help_file) {
8362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8366                 }
8367                 if (r->monitor_name) {
8368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8371                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8372                 }
8373                 if (r->default_datatype) {
8374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8378                 }
8379                 if (r->dependent_files) {
8380                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8381                 }
8382                 if (r->previous_names) {
8383                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8384                 }
8385                 if (r->manufacturer_name) {
8386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8390                 }
8391                 if (r->manufacturer_url) {
8392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8396                 }
8397                 if (r->hardware_id) {
8398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8402                 }
8403                 if (r->provider) {
8404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8408                 }
8409         }
8410         return NDR_ERR_SUCCESS;
8411 }
8412
8413 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8414 {
8415         uint32_t _ptr_driver_name;
8416         TALLOC_CTX *_mem_save_driver_name_0;
8417         uint32_t _ptr_architecture;
8418         TALLOC_CTX *_mem_save_architecture_0;
8419         uint32_t _ptr_driver_path;
8420         TALLOC_CTX *_mem_save_driver_path_0;
8421         uint32_t _ptr_data_file;
8422         TALLOC_CTX *_mem_save_data_file_0;
8423         uint32_t _ptr_config_file;
8424         TALLOC_CTX *_mem_save_config_file_0;
8425         uint32_t _ptr_help_file;
8426         TALLOC_CTX *_mem_save_help_file_0;
8427         uint32_t _ptr_monitor_name;
8428         TALLOC_CTX *_mem_save_monitor_name_0;
8429         uint32_t _ptr_default_datatype;
8430         TALLOC_CTX *_mem_save_default_datatype_0;
8431         uint32_t _ptr_dependent_files;
8432         TALLOC_CTX *_mem_save_dependent_files_0;
8433         uint32_t _ptr_previous_names;
8434         TALLOC_CTX *_mem_save_previous_names_0;
8435         uint32_t _ptr_manufacturer_name;
8436         TALLOC_CTX *_mem_save_manufacturer_name_0;
8437         uint32_t _ptr_manufacturer_url;
8438         TALLOC_CTX *_mem_save_manufacturer_url_0;
8439         uint32_t _ptr_hardware_id;
8440         TALLOC_CTX *_mem_save_hardware_id_0;
8441         uint32_t _ptr_provider;
8442         TALLOC_CTX *_mem_save_provider_0;
8443         if (ndr_flags & NDR_SCALARS) {
8444                 NDR_CHECK(ndr_pull_align(ndr, 8));
8445                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8447                 if (_ptr_driver_name) {
8448                         NDR_PULL_ALLOC(ndr, r->driver_name);
8449                 } else {
8450                         r->driver_name = NULL;
8451                 }
8452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8453                 if (_ptr_architecture) {
8454                         NDR_PULL_ALLOC(ndr, r->architecture);
8455                 } else {
8456                         r->architecture = NULL;
8457                 }
8458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8459                 if (_ptr_driver_path) {
8460                         NDR_PULL_ALLOC(ndr, r->driver_path);
8461                 } else {
8462                         r->driver_path = NULL;
8463                 }
8464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8465                 if (_ptr_data_file) {
8466                         NDR_PULL_ALLOC(ndr, r->data_file);
8467                 } else {
8468                         r->data_file = NULL;
8469                 }
8470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8471                 if (_ptr_config_file) {
8472                         NDR_PULL_ALLOC(ndr, r->config_file);
8473                 } else {
8474                         r->config_file = NULL;
8475                 }
8476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8477                 if (_ptr_help_file) {
8478                         NDR_PULL_ALLOC(ndr, r->help_file);
8479                 } else {
8480                         r->help_file = NULL;
8481                 }
8482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8483                 if (_ptr_monitor_name) {
8484                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8485                 } else {
8486                         r->monitor_name = NULL;
8487                 }
8488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8489                 if (_ptr_default_datatype) {
8490                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8491                 } else {
8492                         r->default_datatype = NULL;
8493                 }
8494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8496                 if (_ptr_dependent_files) {
8497                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8498                 } else {
8499                         r->dependent_files = NULL;
8500                 }
8501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8503                 if (_ptr_previous_names) {
8504                         NDR_PULL_ALLOC(ndr, r->previous_names);
8505                 } else {
8506                         r->previous_names = NULL;
8507                 }
8508                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8509                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8511                 if (_ptr_manufacturer_name) {
8512                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8513                 } else {
8514                         r->manufacturer_name = NULL;
8515                 }
8516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8517                 if (_ptr_manufacturer_url) {
8518                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8519                 } else {
8520                         r->manufacturer_url = NULL;
8521                 }
8522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8523                 if (_ptr_hardware_id) {
8524                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8525                 } else {
8526                         r->hardware_id = NULL;
8527                 }
8528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8529                 if (_ptr_provider) {
8530                         NDR_PULL_ALLOC(ndr, r->provider);
8531                 } else {
8532                         r->provider = NULL;
8533                 }
8534         }
8535         if (ndr_flags & NDR_BUFFERS) {
8536                 if (r->driver_name) {
8537                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8538                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8541                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8542                                 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));
8543                         }
8544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8547                 }
8548                 if (r->architecture) {
8549                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8550                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8552                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8553                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8554                                 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));
8555                         }
8556                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8559                 }
8560                 if (r->driver_path) {
8561                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8562                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8565                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8566                                 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));
8567                         }
8568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8569                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8571                 }
8572                 if (r->data_file) {
8573                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8574                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8577                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8578                                 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));
8579                         }
8580                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8583                 }
8584                 if (r->config_file) {
8585                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8586                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8589                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8590                                 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));
8591                         }
8592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8595                 }
8596                 if (r->help_file) {
8597                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8598                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8601                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8602                                 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));
8603                         }
8604                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8605                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8607                 }
8608                 if (r->monitor_name) {
8609                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8610                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8612                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8613                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8614                                 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));
8615                         }
8616                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8617                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8619                 }
8620                 if (r->default_datatype) {
8621                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8622                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8625                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8626                                 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));
8627                         }
8628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8631                 }
8632                 if (r->dependent_files) {
8633                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8634                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8635                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8637                 }
8638                 if (r->previous_names) {
8639                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8640                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8641                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8643                 }
8644                 if (r->manufacturer_name) {
8645                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8646                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8649                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8650                                 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));
8651                         }
8652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8655                 }
8656                 if (r->manufacturer_url) {
8657                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8658                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8661                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8662                                 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));
8663                         }
8664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8667                 }
8668                 if (r->hardware_id) {
8669                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8670                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8673                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8674                                 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));
8675                         }
8676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8679                 }
8680                 if (r->provider) {
8681                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8682                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8685                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8686                                 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));
8687                         }
8688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8689                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8691                 }
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8697 {
8698         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8699         ndr->depth++;
8700         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8701         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8702         ndr->depth++;
8703         if (r->driver_name) {
8704                 ndr_print_string(ndr, "driver_name", r->driver_name);
8705         }
8706         ndr->depth--;
8707         ndr_print_ptr(ndr, "architecture", r->architecture);
8708         ndr->depth++;
8709         if (r->architecture) {
8710                 ndr_print_string(ndr, "architecture", r->architecture);
8711         }
8712         ndr->depth--;
8713         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8714         ndr->depth++;
8715         if (r->driver_path) {
8716                 ndr_print_string(ndr, "driver_path", r->driver_path);
8717         }
8718         ndr->depth--;
8719         ndr_print_ptr(ndr, "data_file", r->data_file);
8720         ndr->depth++;
8721         if (r->data_file) {
8722                 ndr_print_string(ndr, "data_file", r->data_file);
8723         }
8724         ndr->depth--;
8725         ndr_print_ptr(ndr, "config_file", r->config_file);
8726         ndr->depth++;
8727         if (r->config_file) {
8728                 ndr_print_string(ndr, "config_file", r->config_file);
8729         }
8730         ndr->depth--;
8731         ndr_print_ptr(ndr, "help_file", r->help_file);
8732         ndr->depth++;
8733         if (r->help_file) {
8734                 ndr_print_string(ndr, "help_file", r->help_file);
8735         }
8736         ndr->depth--;
8737         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8738         ndr->depth++;
8739         if (r->monitor_name) {
8740                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8741         }
8742         ndr->depth--;
8743         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8744         ndr->depth++;
8745         if (r->default_datatype) {
8746                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8747         }
8748         ndr->depth--;
8749         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);
8750         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8751         ndr->depth++;
8752         if (r->dependent_files) {
8753                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8754         }
8755         ndr->depth--;
8756         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);
8757         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8758         ndr->depth++;
8759         if (r->previous_names) {
8760                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8761         }
8762         ndr->depth--;
8763         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8764         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8765         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8766         ndr->depth++;
8767         if (r->manufacturer_name) {
8768                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8769         }
8770         ndr->depth--;
8771         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8772         ndr->depth++;
8773         if (r->manufacturer_url) {
8774                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8775         }
8776         ndr->depth--;
8777         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8778         ndr->depth++;
8779         if (r->hardware_id) {
8780                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8781         }
8782         ndr->depth--;
8783         ndr_print_ptr(ndr, "provider", r->provider);
8784         ndr->depth++;
8785         if (r->provider) {
8786                 ndr_print_string(ndr, "provider", r->provider);
8787         }
8788         ndr->depth--;
8789         ndr->depth--;
8790 }
8791
8792 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8793 {
8794         if (ndr_flags & NDR_SCALARS) {
8795                 NDR_CHECK(ndr_push_align(ndr, 8));
8796                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8809                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8810                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8819                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8823                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8824                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8825         }
8826         if (ndr_flags & NDR_BUFFERS) {
8827                 if (r->driver_name) {
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8831                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8832                 }
8833                 if (r->architecture) {
8834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8837                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8838                 }
8839                 if (r->driver_path) {
8840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8844                 }
8845                 if (r->data_file) {
8846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8848                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8849                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8850                 }
8851                 if (r->config_file) {
8852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8856                 }
8857                 if (r->help_file) {
8858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8862                 }
8863                 if (r->monitor_name) {
8864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8868                 }
8869                 if (r->default_datatype) {
8870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8874                 }
8875                 if (r->dependent_files) {
8876                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8877                 }
8878                 if (r->previous_names) {
8879                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8880                 }
8881                 if (r->manufacturer_name) {
8882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8885                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8886                 }
8887                 if (r->manufacturer_url) {
8888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8891                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8892                 }
8893                 if (r->hardware_id) {
8894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8897                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8898                 }
8899                 if (r->provider) {
8900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8904                 }
8905                 if (r->print_processor) {
8906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8910                 }
8911                 if (r->vendor_setup) {
8912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8916                 }
8917                 if (r->color_profiles) {
8918                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8919                 }
8920                 if (r->inf_path) {
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8925                 }
8926                 if (r->core_driver_dependencies) {
8927                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8928                 }
8929         }
8930         return NDR_ERR_SUCCESS;
8931 }
8932
8933 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8934 {
8935         uint32_t _ptr_driver_name;
8936         TALLOC_CTX *_mem_save_driver_name_0;
8937         uint32_t _ptr_architecture;
8938         TALLOC_CTX *_mem_save_architecture_0;
8939         uint32_t _ptr_driver_path;
8940         TALLOC_CTX *_mem_save_driver_path_0;
8941         uint32_t _ptr_data_file;
8942         TALLOC_CTX *_mem_save_data_file_0;
8943         uint32_t _ptr_config_file;
8944         TALLOC_CTX *_mem_save_config_file_0;
8945         uint32_t _ptr_help_file;
8946         TALLOC_CTX *_mem_save_help_file_0;
8947         uint32_t _ptr_monitor_name;
8948         TALLOC_CTX *_mem_save_monitor_name_0;
8949         uint32_t _ptr_default_datatype;
8950         TALLOC_CTX *_mem_save_default_datatype_0;
8951         uint32_t _ptr_dependent_files;
8952         TALLOC_CTX *_mem_save_dependent_files_0;
8953         uint32_t _ptr_previous_names;
8954         TALLOC_CTX *_mem_save_previous_names_0;
8955         uint32_t _ptr_manufacturer_name;
8956         TALLOC_CTX *_mem_save_manufacturer_name_0;
8957         uint32_t _ptr_manufacturer_url;
8958         TALLOC_CTX *_mem_save_manufacturer_url_0;
8959         uint32_t _ptr_hardware_id;
8960         TALLOC_CTX *_mem_save_hardware_id_0;
8961         uint32_t _ptr_provider;
8962         TALLOC_CTX *_mem_save_provider_0;
8963         uint32_t _ptr_print_processor;
8964         TALLOC_CTX *_mem_save_print_processor_0;
8965         uint32_t _ptr_vendor_setup;
8966         TALLOC_CTX *_mem_save_vendor_setup_0;
8967         uint32_t _ptr_color_profiles;
8968         TALLOC_CTX *_mem_save_color_profiles_0;
8969         uint32_t _ptr_inf_path;
8970         TALLOC_CTX *_mem_save_inf_path_0;
8971         uint32_t _ptr_core_driver_dependencies;
8972         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
8973         if (ndr_flags & NDR_SCALARS) {
8974                 NDR_CHECK(ndr_pull_align(ndr, 8));
8975                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8977                 if (_ptr_driver_name) {
8978                         NDR_PULL_ALLOC(ndr, r->driver_name);
8979                 } else {
8980                         r->driver_name = NULL;
8981                 }
8982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8983                 if (_ptr_architecture) {
8984                         NDR_PULL_ALLOC(ndr, r->architecture);
8985                 } else {
8986                         r->architecture = NULL;
8987                 }
8988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8989                 if (_ptr_driver_path) {
8990                         NDR_PULL_ALLOC(ndr, r->driver_path);
8991                 } else {
8992                         r->driver_path = NULL;
8993                 }
8994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8995                 if (_ptr_data_file) {
8996                         NDR_PULL_ALLOC(ndr, r->data_file);
8997                 } else {
8998                         r->data_file = NULL;
8999                 }
9000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9001                 if (_ptr_config_file) {
9002                         NDR_PULL_ALLOC(ndr, r->config_file);
9003                 } else {
9004                         r->config_file = NULL;
9005                 }
9006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9007                 if (_ptr_help_file) {
9008                         NDR_PULL_ALLOC(ndr, r->help_file);
9009                 } else {
9010                         r->help_file = NULL;
9011                 }
9012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9013                 if (_ptr_monitor_name) {
9014                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9015                 } else {
9016                         r->monitor_name = NULL;
9017                 }
9018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9019                 if (_ptr_default_datatype) {
9020                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9021                 } else {
9022                         r->default_datatype = NULL;
9023                 }
9024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9026                 if (_ptr_dependent_files) {
9027                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9028                 } else {
9029                         r->dependent_files = NULL;
9030                 }
9031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9033                 if (_ptr_previous_names) {
9034                         NDR_PULL_ALLOC(ndr, r->previous_names);
9035                 } else {
9036                         r->previous_names = NULL;
9037                 }
9038                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9039                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9041                 if (_ptr_manufacturer_name) {
9042                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9043                 } else {
9044                         r->manufacturer_name = NULL;
9045                 }
9046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9047                 if (_ptr_manufacturer_url) {
9048                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9049                 } else {
9050                         r->manufacturer_url = NULL;
9051                 }
9052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9053                 if (_ptr_hardware_id) {
9054                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9055                 } else {
9056                         r->hardware_id = NULL;
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9059                 if (_ptr_provider) {
9060                         NDR_PULL_ALLOC(ndr, r->provider);
9061                 } else {
9062                         r->provider = NULL;
9063                 }
9064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9065                 if (_ptr_print_processor) {
9066                         NDR_PULL_ALLOC(ndr, r->print_processor);
9067                 } else {
9068                         r->print_processor = NULL;
9069                 }
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9071                 if (_ptr_vendor_setup) {
9072                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9073                 } else {
9074                         r->vendor_setup = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9078                 if (_ptr_color_profiles) {
9079                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9080                 } else {
9081                         r->color_profiles = NULL;
9082                 }
9083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9084                 if (_ptr_inf_path) {
9085                         NDR_PULL_ALLOC(ndr, r->inf_path);
9086                 } else {
9087                         r->inf_path = NULL;
9088                 }
9089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9092                 if (_ptr_core_driver_dependencies) {
9093                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9094                 } else {
9095                         r->core_driver_dependencies = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9098                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9099         }
9100         if (ndr_flags & NDR_BUFFERS) {
9101                 if (r->driver_name) {
9102                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9103                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9106                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9107                                 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));
9108                         }
9109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9112                 }
9113                 if (r->architecture) {
9114                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9115                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9118                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9119                                 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));
9120                         }
9121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9124                 }
9125                 if (r->driver_path) {
9126                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9127                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9130                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9131                                 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));
9132                         }
9133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9136                 }
9137                 if (r->data_file) {
9138                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9139                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9142                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9143                                 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));
9144                         }
9145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9148                 }
9149                 if (r->config_file) {
9150                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9151                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9153                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9154                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9155                                 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));
9156                         }
9157                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9158                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9160                 }
9161                 if (r->help_file) {
9162                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9163                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9166                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9167                                 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));
9168                         }
9169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9172                 }
9173                 if (r->monitor_name) {
9174                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9175                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9178                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9179                                 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));
9180                         }
9181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9184                 }
9185                 if (r->default_datatype) {
9186                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9187                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9189                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9190                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9191                                 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));
9192                         }
9193                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9194                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9196                 }
9197                 if (r->dependent_files) {
9198                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9199                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9200                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9202                 }
9203                 if (r->previous_names) {
9204                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9205                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9206                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9208                 }
9209                 if (r->manufacturer_name) {
9210                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9211                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9212                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9213                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9214                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9215                                 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));
9216                         }
9217                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9220                 }
9221                 if (r->manufacturer_url) {
9222                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9223                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9224                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9225                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9226                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9227                                 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));
9228                         }
9229                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9232                 }
9233                 if (r->hardware_id) {
9234                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9235                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9238                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9239                                 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));
9240                         }
9241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9244                 }
9245                 if (r->provider) {
9246                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9247                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9250                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9251                                 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));
9252                         }
9253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9256                 }
9257                 if (r->print_processor) {
9258                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9259                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9262                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9263                                 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));
9264                         }
9265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9268                 }
9269                 if (r->vendor_setup) {
9270                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9271                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9274                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9275                                 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));
9276                         }
9277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9280                 }
9281                 if (r->color_profiles) {
9282                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9283                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9284                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9286                 }
9287                 if (r->inf_path) {
9288                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9289                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9292                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9293                                 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));
9294                         }
9295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9298                 }
9299                 if (r->core_driver_dependencies) {
9300                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9301                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9302                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9304                 }
9305         }
9306         return NDR_ERR_SUCCESS;
9307 }
9308
9309 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9310 {
9311         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9312         ndr->depth++;
9313         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9314         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9315         ndr->depth++;
9316         if (r->driver_name) {
9317                 ndr_print_string(ndr, "driver_name", r->driver_name);
9318         }
9319         ndr->depth--;
9320         ndr_print_ptr(ndr, "architecture", r->architecture);
9321         ndr->depth++;
9322         if (r->architecture) {
9323                 ndr_print_string(ndr, "architecture", r->architecture);
9324         }
9325         ndr->depth--;
9326         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9327         ndr->depth++;
9328         if (r->driver_path) {
9329                 ndr_print_string(ndr, "driver_path", r->driver_path);
9330         }
9331         ndr->depth--;
9332         ndr_print_ptr(ndr, "data_file", r->data_file);
9333         ndr->depth++;
9334         if (r->data_file) {
9335                 ndr_print_string(ndr, "data_file", r->data_file);
9336         }
9337         ndr->depth--;
9338         ndr_print_ptr(ndr, "config_file", r->config_file);
9339         ndr->depth++;
9340         if (r->config_file) {
9341                 ndr_print_string(ndr, "config_file", r->config_file);
9342         }
9343         ndr->depth--;
9344         ndr_print_ptr(ndr, "help_file", r->help_file);
9345         ndr->depth++;
9346         if (r->help_file) {
9347                 ndr_print_string(ndr, "help_file", r->help_file);
9348         }
9349         ndr->depth--;
9350         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9351         ndr->depth++;
9352         if (r->monitor_name) {
9353                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9354         }
9355         ndr->depth--;
9356         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9357         ndr->depth++;
9358         if (r->default_datatype) {
9359                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9360         }
9361         ndr->depth--;
9362         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);
9363         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9364         ndr->depth++;
9365         if (r->dependent_files) {
9366                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9367         }
9368         ndr->depth--;
9369         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);
9370         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9371         ndr->depth++;
9372         if (r->previous_names) {
9373                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9374         }
9375         ndr->depth--;
9376         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9377         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9378         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9379         ndr->depth++;
9380         if (r->manufacturer_name) {
9381                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9382         }
9383         ndr->depth--;
9384         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9385         ndr->depth++;
9386         if (r->manufacturer_url) {
9387                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9388         }
9389         ndr->depth--;
9390         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9391         ndr->depth++;
9392         if (r->hardware_id) {
9393                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9394         }
9395         ndr->depth--;
9396         ndr_print_ptr(ndr, "provider", r->provider);
9397         ndr->depth++;
9398         if (r->provider) {
9399                 ndr_print_string(ndr, "provider", r->provider);
9400         }
9401         ndr->depth--;
9402         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9403         ndr->depth++;
9404         if (r->print_processor) {
9405                 ndr_print_string(ndr, "print_processor", r->print_processor);
9406         }
9407         ndr->depth--;
9408         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9409         ndr->depth++;
9410         if (r->vendor_setup) {
9411                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9412         }
9413         ndr->depth--;
9414         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);
9415         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9416         ndr->depth++;
9417         if (r->color_profiles) {
9418                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9419         }
9420         ndr->depth--;
9421         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9422         ndr->depth++;
9423         if (r->inf_path) {
9424                 ndr_print_string(ndr, "inf_path", r->inf_path);
9425         }
9426         ndr->depth--;
9427         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9428         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);
9429         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9430         ndr->depth++;
9431         if (r->core_driver_dependencies) {
9432                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9433         }
9434         ndr->depth--;
9435         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9436         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9437         ndr->depth--;
9438 }
9439
9440 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9441 {
9442         if (ndr_flags & NDR_SCALARS) {
9443                 int level = ndr_push_get_switch_value(ndr, r);
9444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9445                 switch (level) {
9446                         case 1: {
9447                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9448                         break; }
9449
9450                         case 2: {
9451                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9452                         break; }
9453
9454                         case 3: {
9455                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9456                         break; }
9457
9458                         case 4: {
9459                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9460                         break; }
9461
9462                         case 6: {
9463                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9464                         break; }
9465
9466                         case 8: {
9467                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9468                         break; }
9469
9470                         default:
9471                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9472                 }
9473         }
9474         if (ndr_flags & NDR_BUFFERS) {
9475                 int level = ndr_push_get_switch_value(ndr, r);
9476                 switch (level) {
9477                         case 1:
9478                                 if (r->info1) {
9479                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9480                                 }
9481                         break;
9482
9483                         case 2:
9484                                 if (r->info2) {
9485                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9486                                 }
9487                         break;
9488
9489                         case 3:
9490                                 if (r->info3) {
9491                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9492                                 }
9493                         break;
9494
9495                         case 4:
9496                                 if (r->info4) {
9497                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9498                                 }
9499                         break;
9500
9501                         case 6:
9502                                 if (r->info6) {
9503                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9504                                 }
9505                         break;
9506
9507                         case 8:
9508                                 if (r->info8) {
9509                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9510                                 }
9511                         break;
9512
9513                         default:
9514                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9515                 }
9516         }
9517         return NDR_ERR_SUCCESS;
9518 }
9519
9520 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9521 {
9522         int level;
9523         uint32_t _level;
9524         TALLOC_CTX *_mem_save_info1_0;
9525         TALLOC_CTX *_mem_save_info2_0;
9526         TALLOC_CTX *_mem_save_info3_0;
9527         TALLOC_CTX *_mem_save_info4_0;
9528         TALLOC_CTX *_mem_save_info6_0;
9529         TALLOC_CTX *_mem_save_info8_0;
9530         level = ndr_pull_get_switch_value(ndr, r);
9531         if (ndr_flags & NDR_SCALARS) {
9532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9533                 if (_level != level) {
9534                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9535                 }
9536                 switch (level) {
9537                         case 1: {
9538                                 uint32_t _ptr_info1;
9539                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9540                                 if (_ptr_info1) {
9541                                         NDR_PULL_ALLOC(ndr, r->info1);
9542                                 } else {
9543                                         r->info1 = NULL;
9544                                 }
9545                         break; }
9546
9547                         case 2: {
9548                                 uint32_t _ptr_info2;
9549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9550                                 if (_ptr_info2) {
9551                                         NDR_PULL_ALLOC(ndr, r->info2);
9552                                 } else {
9553                                         r->info2 = NULL;
9554                                 }
9555                         break; }
9556
9557                         case 3: {
9558                                 uint32_t _ptr_info3;
9559                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9560                                 if (_ptr_info3) {
9561                                         NDR_PULL_ALLOC(ndr, r->info3);
9562                                 } else {
9563                                         r->info3 = NULL;
9564                                 }
9565                         break; }
9566
9567                         case 4: {
9568                                 uint32_t _ptr_info4;
9569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9570                                 if (_ptr_info4) {
9571                                         NDR_PULL_ALLOC(ndr, r->info4);
9572                                 } else {
9573                                         r->info4 = NULL;
9574                                 }
9575                         break; }
9576
9577                         case 6: {
9578                                 uint32_t _ptr_info6;
9579                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9580                                 if (_ptr_info6) {
9581                                         NDR_PULL_ALLOC(ndr, r->info6);
9582                                 } else {
9583                                         r->info6 = NULL;
9584                                 }
9585                         break; }
9586
9587                         case 8: {
9588                                 uint32_t _ptr_info8;
9589                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9590                                 if (_ptr_info8) {
9591                                         NDR_PULL_ALLOC(ndr, r->info8);
9592                                 } else {
9593                                         r->info8 = NULL;
9594                                 }
9595                         break; }
9596
9597                         default:
9598                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9599                 }
9600         }
9601         if (ndr_flags & NDR_BUFFERS) {
9602                 switch (level) {
9603                         case 1:
9604                                 if (r->info1) {
9605                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9606                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9607                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9608                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9609                                 }
9610                         break;
9611
9612                         case 2:
9613                                 if (r->info2) {
9614                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9616                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9618                                 }
9619                         break;
9620
9621                         case 3:
9622                                 if (r->info3) {
9623                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9625                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9627                                 }
9628                         break;
9629
9630                         case 4:
9631                                 if (r->info4) {
9632                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9633                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9634                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9635                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9636                                 }
9637                         break;
9638
9639                         case 6:
9640                                 if (r->info6) {
9641                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9642                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9643                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9644                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9645                                 }
9646                         break;
9647
9648                         case 8:
9649                                 if (r->info8) {
9650                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9652                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9654                                 }
9655                         break;
9656
9657                         default:
9658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9659                 }
9660         }
9661         return NDR_ERR_SUCCESS;
9662 }
9663
9664 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9665 {
9666         int level;
9667         level = ndr_print_get_switch_value(ndr, r);
9668         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9669         switch (level) {
9670                 case 1:
9671                         ndr_print_ptr(ndr, "info1", r->info1);
9672                         ndr->depth++;
9673                         if (r->info1) {
9674                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9675                         }
9676                         ndr->depth--;
9677                 break;
9678
9679                 case 2:
9680                         ndr_print_ptr(ndr, "info2", r->info2);
9681                         ndr->depth++;
9682                         if (r->info2) {
9683                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9684                         }
9685                         ndr->depth--;
9686                 break;
9687
9688                 case 3:
9689                         ndr_print_ptr(ndr, "info3", r->info3);
9690                         ndr->depth++;
9691                         if (r->info3) {
9692                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9693                         }
9694                         ndr->depth--;
9695                 break;
9696
9697                 case 4:
9698                         ndr_print_ptr(ndr, "info4", r->info4);
9699                         ndr->depth++;
9700                         if (r->info4) {
9701                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9702                         }
9703                         ndr->depth--;
9704                 break;
9705
9706                 case 6:
9707                         ndr_print_ptr(ndr, "info6", r->info6);
9708                         ndr->depth++;
9709                         if (r->info6) {
9710                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9711                         }
9712                         ndr->depth--;
9713                 break;
9714
9715                 case 8:
9716                         ndr_print_ptr(ndr, "info8", r->info8);
9717                         ndr->depth++;
9718                         if (r->info8) {
9719                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9720                         }
9721                         ndr->depth--;
9722                 break;
9723
9724                 default:
9725                         ndr_print_bad_level(ndr, name, level);
9726         }
9727 }
9728
9729 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9730 {
9731         if (ndr_flags & NDR_SCALARS) {
9732                 NDR_CHECK(ndr_push_align(ndr, 4));
9733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9734                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9735                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9736         }
9737         if (ndr_flags & NDR_BUFFERS) {
9738                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9739         }
9740         return NDR_ERR_SUCCESS;
9741 }
9742
9743 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9744 {
9745         if (ndr_flags & NDR_SCALARS) {
9746                 NDR_CHECK(ndr_pull_align(ndr, 4));
9747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9748                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9749                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9750         }
9751         if (ndr_flags & NDR_BUFFERS) {
9752                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9753         }
9754         return NDR_ERR_SUCCESS;
9755 }
9756
9757 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9758 {
9759         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9760         ndr->depth++;
9761         ndr_print_uint32(ndr, "level", r->level);
9762         ndr_print_set_switch_value(ndr, &r->info, r->level);
9763         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9764         ndr->depth--;
9765 }
9766
9767 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9768 {
9769         if (ndr_flags & NDR_SCALARS) {
9770                 NDR_CHECK(ndr_push_align(ndr, 4));
9771                 {
9772                         uint32_t _flags_save_string = ndr->flags;
9773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9775                         ndr->flags = _flags_save_string;
9776                 }
9777         }
9778         if (ndr_flags & NDR_BUFFERS) {
9779                 {
9780                         uint32_t _flags_save_string = ndr->flags;
9781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9782                         if (r->driver_name) {
9783                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9784                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9785                         }
9786                         ndr->flags = _flags_save_string;
9787                 }
9788         }
9789         return NDR_ERR_SUCCESS;
9790 }
9791
9792 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9793 {
9794         uint32_t _ptr_driver_name;
9795         TALLOC_CTX *_mem_save_driver_name_0;
9796         if (ndr_flags & NDR_SCALARS) {
9797                 NDR_CHECK(ndr_pull_align(ndr, 4));
9798                 {
9799                         uint32_t _flags_save_string = ndr->flags;
9800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9802                         if (_ptr_driver_name) {
9803                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9805                         } else {
9806                                 r->driver_name = NULL;
9807                         }
9808                         ndr->flags = _flags_save_string;
9809                 }
9810         }
9811         if (ndr_flags & NDR_BUFFERS) {
9812                 {
9813                         uint32_t _flags_save_string = ndr->flags;
9814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9815                         if (r->driver_name) {
9816                                 uint32_t _relative_save_offset;
9817                                 _relative_save_offset = ndr->offset;
9818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9819                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9820                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9823                                 ndr->offset = _relative_save_offset;
9824                         }
9825                         ndr->flags = _flags_save_string;
9826                 }
9827         }
9828         return NDR_ERR_SUCCESS;
9829 }
9830
9831 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9832 {
9833         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9834         ndr->depth++;
9835         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9836         ndr->depth++;
9837         if (r->driver_name) {
9838                 ndr_print_string(ndr, "driver_name", r->driver_name);
9839         }
9840         ndr->depth--;
9841         ndr->depth--;
9842 }
9843
9844 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9845 {
9846         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9847 }
9848
9849 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9850 {
9851         if (ndr_flags & NDR_SCALARS) {
9852                 NDR_CHECK(ndr_push_align(ndr, 4));
9853                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9854                 {
9855                         uint32_t _flags_save_string = ndr->flags;
9856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9857                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9858                         ndr->flags = _flags_save_string;
9859                 }
9860                 {
9861                         uint32_t _flags_save_string = ndr->flags;
9862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9864                         ndr->flags = _flags_save_string;
9865                 }
9866                 {
9867                         uint32_t _flags_save_string = ndr->flags;
9868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9870                         ndr->flags = _flags_save_string;
9871                 }
9872                 {
9873                         uint32_t _flags_save_string = ndr->flags;
9874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9875                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9876                         ndr->flags = _flags_save_string;
9877                 }
9878                 {
9879                         uint32_t _flags_save_string = ndr->flags;
9880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9881                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9882                         ndr->flags = _flags_save_string;
9883                 }
9884         }
9885         if (ndr_flags & NDR_BUFFERS) {
9886                 {
9887                         uint32_t _flags_save_string = ndr->flags;
9888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9889                         if (r->driver_name) {
9890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9892                         }
9893                         ndr->flags = _flags_save_string;
9894                 }
9895                 {
9896                         uint32_t _flags_save_string = ndr->flags;
9897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9898                         if (r->architecture) {
9899                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9900                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9901                         }
9902                         ndr->flags = _flags_save_string;
9903                 }
9904                 {
9905                         uint32_t _flags_save_string = ndr->flags;
9906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9907                         if (r->driver_path) {
9908                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9909                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9910                         }
9911                         ndr->flags = _flags_save_string;
9912                 }
9913                 {
9914                         uint32_t _flags_save_string = ndr->flags;
9915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9916                         if (r->data_file) {
9917                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9918                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9919                         }
9920                         ndr->flags = _flags_save_string;
9921                 }
9922                 {
9923                         uint32_t _flags_save_string = ndr->flags;
9924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9925                         if (r->config_file) {
9926                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9928                         }
9929                         ndr->flags = _flags_save_string;
9930                 }
9931         }
9932         return NDR_ERR_SUCCESS;
9933 }
9934
9935 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9936 {
9937         uint32_t _ptr_driver_name;
9938         TALLOC_CTX *_mem_save_driver_name_0;
9939         uint32_t _ptr_architecture;
9940         TALLOC_CTX *_mem_save_architecture_0;
9941         uint32_t _ptr_driver_path;
9942         TALLOC_CTX *_mem_save_driver_path_0;
9943         uint32_t _ptr_data_file;
9944         TALLOC_CTX *_mem_save_data_file_0;
9945         uint32_t _ptr_config_file;
9946         TALLOC_CTX *_mem_save_config_file_0;
9947         if (ndr_flags & NDR_SCALARS) {
9948                 NDR_CHECK(ndr_pull_align(ndr, 4));
9949                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9950                 {
9951                         uint32_t _flags_save_string = ndr->flags;
9952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9953                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9954                         if (_ptr_driver_name) {
9955                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9956                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9957                         } else {
9958                                 r->driver_name = NULL;
9959                         }
9960                         ndr->flags = _flags_save_string;
9961                 }
9962                 {
9963                         uint32_t _flags_save_string = ndr->flags;
9964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9965                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9966                         if (_ptr_architecture) {
9967                                 NDR_PULL_ALLOC(ndr, r->architecture);
9968                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9969                         } else {
9970                                 r->architecture = NULL;
9971                         }
9972                         ndr->flags = _flags_save_string;
9973                 }
9974                 {
9975                         uint32_t _flags_save_string = ndr->flags;
9976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9977                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9978                         if (_ptr_driver_path) {
9979                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9980                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9981                         } else {
9982                                 r->driver_path = NULL;
9983                         }
9984                         ndr->flags = _flags_save_string;
9985                 }
9986                 {
9987                         uint32_t _flags_save_string = ndr->flags;
9988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9989                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9990                         if (_ptr_data_file) {
9991                                 NDR_PULL_ALLOC(ndr, r->data_file);
9992                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9993                         } else {
9994                                 r->data_file = NULL;
9995                         }
9996                         ndr->flags = _flags_save_string;
9997                 }
9998                 {
9999                         uint32_t _flags_save_string = ndr->flags;
10000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10001                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10002                         if (_ptr_config_file) {
10003                                 NDR_PULL_ALLOC(ndr, r->config_file);
10004                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10005                         } else {
10006                                 r->config_file = NULL;
10007                         }
10008                         ndr->flags = _flags_save_string;
10009                 }
10010         }
10011         if (ndr_flags & NDR_BUFFERS) {
10012                 {
10013                         uint32_t _flags_save_string = ndr->flags;
10014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10015                         if (r->driver_name) {
10016                                 uint32_t _relative_save_offset;
10017                                 _relative_save_offset = ndr->offset;
10018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10019                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10023                                 ndr->offset = _relative_save_offset;
10024                         }
10025                         ndr->flags = _flags_save_string;
10026                 }
10027                 {
10028                         uint32_t _flags_save_string = ndr->flags;
10029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10030                         if (r->architecture) {
10031                                 uint32_t _relative_save_offset;
10032                                 _relative_save_offset = ndr->offset;
10033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10034                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10035                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10038                                 ndr->offset = _relative_save_offset;
10039                         }
10040                         ndr->flags = _flags_save_string;
10041                 }
10042                 {
10043                         uint32_t _flags_save_string = ndr->flags;
10044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10045                         if (r->driver_path) {
10046                                 uint32_t _relative_save_offset;
10047                                 _relative_save_offset = ndr->offset;
10048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10049                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10050                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10053                                 ndr->offset = _relative_save_offset;
10054                         }
10055                         ndr->flags = _flags_save_string;
10056                 }
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         if (r->data_file) {
10061                                 uint32_t _relative_save_offset;
10062                                 _relative_save_offset = ndr->offset;
10063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10064                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10065                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10068                                 ndr->offset = _relative_save_offset;
10069                         }
10070                         ndr->flags = _flags_save_string;
10071                 }
10072                 {
10073                         uint32_t _flags_save_string = ndr->flags;
10074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10075                         if (r->config_file) {
10076                                 uint32_t _relative_save_offset;
10077                                 _relative_save_offset = ndr->offset;
10078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10079                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10083                                 ndr->offset = _relative_save_offset;
10084                         }
10085                         ndr->flags = _flags_save_string;
10086                 }
10087         }
10088         return NDR_ERR_SUCCESS;
10089 }
10090
10091 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10092 {
10093         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10094         ndr->depth++;
10095         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10096         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10097         ndr->depth++;
10098         if (r->driver_name) {
10099                 ndr_print_string(ndr, "driver_name", r->driver_name);
10100         }
10101         ndr->depth--;
10102         ndr_print_ptr(ndr, "architecture", r->architecture);
10103         ndr->depth++;
10104         if (r->architecture) {
10105                 ndr_print_string(ndr, "architecture", r->architecture);
10106         }
10107         ndr->depth--;
10108         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10109         ndr->depth++;
10110         if (r->driver_path) {
10111                 ndr_print_string(ndr, "driver_path", r->driver_path);
10112         }
10113         ndr->depth--;
10114         ndr_print_ptr(ndr, "data_file", r->data_file);
10115         ndr->depth++;
10116         if (r->data_file) {
10117                 ndr_print_string(ndr, "data_file", r->data_file);
10118         }
10119         ndr->depth--;
10120         ndr_print_ptr(ndr, "config_file", r->config_file);
10121         ndr->depth++;
10122         if (r->config_file) {
10123                 ndr_print_string(ndr, "config_file", r->config_file);
10124         }
10125         ndr->depth--;
10126         ndr->depth--;
10127 }
10128
10129 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10130 {
10131         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10132 }
10133
10134 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10135 {
10136         if (ndr_flags & NDR_SCALARS) {
10137                 NDR_CHECK(ndr_push_align(ndr, 4));
10138                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10139                 {
10140                         uint32_t _flags_save_string = ndr->flags;
10141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10142                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10143                         ndr->flags = _flags_save_string;
10144                 }
10145                 {
10146                         uint32_t _flags_save_string = ndr->flags;
10147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10148                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10149                         ndr->flags = _flags_save_string;
10150                 }
10151                 {
10152                         uint32_t _flags_save_string = ndr->flags;
10153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10154                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10155                         ndr->flags = _flags_save_string;
10156                 }
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10161                         ndr->flags = _flags_save_string;
10162                 }
10163                 {
10164                         uint32_t _flags_save_string = ndr->flags;
10165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10166                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10167                         ndr->flags = _flags_save_string;
10168                 }
10169                 {
10170                         uint32_t _flags_save_string = ndr->flags;
10171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10172                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10173                         ndr->flags = _flags_save_string;
10174                 }
10175                 {
10176                         uint32_t _flags_save_string_array = ndr->flags;
10177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10178                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10179                         ndr->flags = _flags_save_string_array;
10180                 }
10181                 {
10182                         uint32_t _flags_save_string = ndr->flags;
10183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10185                         ndr->flags = _flags_save_string;
10186                 }
10187                 {
10188                         uint32_t _flags_save_string = ndr->flags;
10189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10191                         ndr->flags = _flags_save_string;
10192                 }
10193         }
10194         if (ndr_flags & NDR_BUFFERS) {
10195                 {
10196                         uint32_t _flags_save_string = ndr->flags;
10197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10198                         if (r->driver_name) {
10199                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10200                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10201                         }
10202                         ndr->flags = _flags_save_string;
10203                 }
10204                 {
10205                         uint32_t _flags_save_string = ndr->flags;
10206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10207                         if (r->architecture) {
10208                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10209                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10210                         }
10211                         ndr->flags = _flags_save_string;
10212                 }
10213                 {
10214                         uint32_t _flags_save_string = ndr->flags;
10215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10216                         if (r->driver_path) {
10217                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10218                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10219                         }
10220                         ndr->flags = _flags_save_string;
10221                 }
10222                 {
10223                         uint32_t _flags_save_string = ndr->flags;
10224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10225                         if (r->data_file) {
10226                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10227                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10228                         }
10229                         ndr->flags = _flags_save_string;
10230                 }
10231                 {
10232                         uint32_t _flags_save_string = ndr->flags;
10233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10234                         if (r->config_file) {
10235                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10236                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10237                         }
10238                         ndr->flags = _flags_save_string;
10239                 }
10240                 {
10241                         uint32_t _flags_save_string = ndr->flags;
10242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10243                         if (r->help_file) {
10244                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10245                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10246                         }
10247                         ndr->flags = _flags_save_string;
10248                 }
10249                 {
10250                         uint32_t _flags_save_string_array = ndr->flags;
10251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10252                         if (r->dependent_files) {
10253                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10254                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10255                         }
10256                         ndr->flags = _flags_save_string_array;
10257                 }
10258                 {
10259                         uint32_t _flags_save_string = ndr->flags;
10260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10261                         if (r->monitor_name) {
10262                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10263                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10264                         }
10265                         ndr->flags = _flags_save_string;
10266                 }
10267                 {
10268                         uint32_t _flags_save_string = ndr->flags;
10269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10270                         if (r->default_datatype) {
10271                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10273                         }
10274                         ndr->flags = _flags_save_string;
10275                 }
10276         }
10277         return NDR_ERR_SUCCESS;
10278 }
10279
10280 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10281 {
10282         uint32_t _ptr_driver_name;
10283         TALLOC_CTX *_mem_save_driver_name_0;
10284         uint32_t _ptr_architecture;
10285         TALLOC_CTX *_mem_save_architecture_0;
10286         uint32_t _ptr_driver_path;
10287         TALLOC_CTX *_mem_save_driver_path_0;
10288         uint32_t _ptr_data_file;
10289         TALLOC_CTX *_mem_save_data_file_0;
10290         uint32_t _ptr_config_file;
10291         TALLOC_CTX *_mem_save_config_file_0;
10292         uint32_t _ptr_help_file;
10293         TALLOC_CTX *_mem_save_help_file_0;
10294         uint32_t _ptr_dependent_files;
10295         TALLOC_CTX *_mem_save_dependent_files_0;
10296         uint32_t _ptr_monitor_name;
10297         TALLOC_CTX *_mem_save_monitor_name_0;
10298         uint32_t _ptr_default_datatype;
10299         TALLOC_CTX *_mem_save_default_datatype_0;
10300         if (ndr_flags & NDR_SCALARS) {
10301                 NDR_CHECK(ndr_pull_align(ndr, 4));
10302                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10303                 {
10304                         uint32_t _flags_save_string = ndr->flags;
10305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10306                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10307                         if (_ptr_driver_name) {
10308                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10309                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10310                         } else {
10311                                 r->driver_name = NULL;
10312                         }
10313                         ndr->flags = _flags_save_string;
10314                 }
10315                 {
10316                         uint32_t _flags_save_string = ndr->flags;
10317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10318                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10319                         if (_ptr_architecture) {
10320                                 NDR_PULL_ALLOC(ndr, r->architecture);
10321                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10322                         } else {
10323                                 r->architecture = NULL;
10324                         }
10325                         ndr->flags = _flags_save_string;
10326                 }
10327                 {
10328                         uint32_t _flags_save_string = ndr->flags;
10329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10331                         if (_ptr_driver_path) {
10332                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10334                         } else {
10335                                 r->driver_path = NULL;
10336                         }
10337                         ndr->flags = _flags_save_string;
10338                 }
10339                 {
10340                         uint32_t _flags_save_string = ndr->flags;
10341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10343                         if (_ptr_data_file) {
10344                                 NDR_PULL_ALLOC(ndr, r->data_file);
10345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10346                         } else {
10347                                 r->data_file = NULL;
10348                         }
10349                         ndr->flags = _flags_save_string;
10350                 }
10351                 {
10352                         uint32_t _flags_save_string = ndr->flags;
10353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10355                         if (_ptr_config_file) {
10356                                 NDR_PULL_ALLOC(ndr, r->config_file);
10357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10358                         } else {
10359                                 r->config_file = NULL;
10360                         }
10361                         ndr->flags = _flags_save_string;
10362                 }
10363                 {
10364                         uint32_t _flags_save_string = ndr->flags;
10365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10367                         if (_ptr_help_file) {
10368                                 NDR_PULL_ALLOC(ndr, r->help_file);
10369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10370                         } else {
10371                                 r->help_file = NULL;
10372                         }
10373                         ndr->flags = _flags_save_string;
10374                 }
10375                 {
10376                         uint32_t _flags_save_string_array = ndr->flags;
10377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10379                         if (_ptr_dependent_files) {
10380                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10382                         } else {
10383                                 r->dependent_files = NULL;
10384                         }
10385                         ndr->flags = _flags_save_string_array;
10386                 }
10387                 {
10388                         uint32_t _flags_save_string = ndr->flags;
10389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10391                         if (_ptr_monitor_name) {
10392                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10394                         } else {
10395                                 r->monitor_name = NULL;
10396                         }
10397                         ndr->flags = _flags_save_string;
10398                 }
10399                 {
10400                         uint32_t _flags_save_string = ndr->flags;
10401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10403                         if (_ptr_default_datatype) {
10404                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10406                         } else {
10407                                 r->default_datatype = NULL;
10408                         }
10409                         ndr->flags = _flags_save_string;
10410                 }
10411         }
10412         if (ndr_flags & NDR_BUFFERS) {
10413                 {
10414                         uint32_t _flags_save_string = ndr->flags;
10415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10416                         if (r->driver_name) {
10417                                 uint32_t _relative_save_offset;
10418                                 _relative_save_offset = ndr->offset;
10419                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10420                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10421                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10422                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10423                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10424                                 ndr->offset = _relative_save_offset;
10425                         }
10426                         ndr->flags = _flags_save_string;
10427                 }
10428                 {
10429                         uint32_t _flags_save_string = ndr->flags;
10430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10431                         if (r->architecture) {
10432                                 uint32_t _relative_save_offset;
10433                                 _relative_save_offset = ndr->offset;
10434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10435                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10436                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10439                                 ndr->offset = _relative_save_offset;
10440                         }
10441                         ndr->flags = _flags_save_string;
10442                 }
10443                 {
10444                         uint32_t _flags_save_string = ndr->flags;
10445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10446                         if (r->driver_path) {
10447                                 uint32_t _relative_save_offset;
10448                                 _relative_save_offset = ndr->offset;
10449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10450                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10454                                 ndr->offset = _relative_save_offset;
10455                         }
10456                         ndr->flags = _flags_save_string;
10457                 }
10458                 {
10459                         uint32_t _flags_save_string = ndr->flags;
10460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10461                         if (r->data_file) {
10462                                 uint32_t _relative_save_offset;
10463                                 _relative_save_offset = ndr->offset;
10464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10465                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10469                                 ndr->offset = _relative_save_offset;
10470                         }
10471                         ndr->flags = _flags_save_string;
10472                 }
10473                 {
10474                         uint32_t _flags_save_string = ndr->flags;
10475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10476                         if (r->config_file) {
10477                                 uint32_t _relative_save_offset;
10478                                 _relative_save_offset = ndr->offset;
10479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10480                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10484                                 ndr->offset = _relative_save_offset;
10485                         }
10486                         ndr->flags = _flags_save_string;
10487                 }
10488                 {
10489                         uint32_t _flags_save_string = ndr->flags;
10490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10491                         if (r->help_file) {
10492                                 uint32_t _relative_save_offset;
10493                                 _relative_save_offset = ndr->offset;
10494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10495                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10496                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10499                                 ndr->offset = _relative_save_offset;
10500                         }
10501                         ndr->flags = _flags_save_string;
10502                 }
10503                 {
10504                         uint32_t _flags_save_string_array = ndr->flags;
10505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10506                         if (r->dependent_files) {
10507                                 uint32_t _relative_save_offset;
10508                                 _relative_save_offset = ndr->offset;
10509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10510                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10511                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10512                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10514                                 ndr->offset = _relative_save_offset;
10515                         }
10516                         ndr->flags = _flags_save_string_array;
10517                 }
10518                 {
10519                         uint32_t _flags_save_string = ndr->flags;
10520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10521                         if (r->monitor_name) {
10522                                 uint32_t _relative_save_offset;
10523                                 _relative_save_offset = ndr->offset;
10524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10525                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10529                                 ndr->offset = _relative_save_offset;
10530                         }
10531                         ndr->flags = _flags_save_string;
10532                 }
10533                 {
10534                         uint32_t _flags_save_string = ndr->flags;
10535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10536                         if (r->default_datatype) {
10537                                 uint32_t _relative_save_offset;
10538                                 _relative_save_offset = ndr->offset;
10539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10540                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10541                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10544                                 ndr->offset = _relative_save_offset;
10545                         }
10546                         ndr->flags = _flags_save_string;
10547                 }
10548         }
10549         return NDR_ERR_SUCCESS;
10550 }
10551
10552 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10553 {
10554         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10555         ndr->depth++;
10556         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10557         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10558         ndr->depth++;
10559         if (r->driver_name) {
10560                 ndr_print_string(ndr, "driver_name", r->driver_name);
10561         }
10562         ndr->depth--;
10563         ndr_print_ptr(ndr, "architecture", r->architecture);
10564         ndr->depth++;
10565         if (r->architecture) {
10566                 ndr_print_string(ndr, "architecture", r->architecture);
10567         }
10568         ndr->depth--;
10569         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10570         ndr->depth++;
10571         if (r->driver_path) {
10572                 ndr_print_string(ndr, "driver_path", r->driver_path);
10573         }
10574         ndr->depth--;
10575         ndr_print_ptr(ndr, "data_file", r->data_file);
10576         ndr->depth++;
10577         if (r->data_file) {
10578                 ndr_print_string(ndr, "data_file", r->data_file);
10579         }
10580         ndr->depth--;
10581         ndr_print_ptr(ndr, "config_file", r->config_file);
10582         ndr->depth++;
10583         if (r->config_file) {
10584                 ndr_print_string(ndr, "config_file", r->config_file);
10585         }
10586         ndr->depth--;
10587         ndr_print_ptr(ndr, "help_file", r->help_file);
10588         ndr->depth++;
10589         if (r->help_file) {
10590                 ndr_print_string(ndr, "help_file", r->help_file);
10591         }
10592         ndr->depth--;
10593         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10594         ndr->depth++;
10595         if (r->dependent_files) {
10596                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10597         }
10598         ndr->depth--;
10599         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10600         ndr->depth++;
10601         if (r->monitor_name) {
10602                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10603         }
10604         ndr->depth--;
10605         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10606         ndr->depth++;
10607         if (r->default_datatype) {
10608                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10609         }
10610         ndr->depth--;
10611         ndr->depth--;
10612 }
10613
10614 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10615 {
10616         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10617 }
10618
10619 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10620 {
10621         if (ndr_flags & NDR_SCALARS) {
10622                 NDR_CHECK(ndr_push_align(ndr, 4));
10623                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10624                 {
10625                         uint32_t _flags_save_string = ndr->flags;
10626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10627                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10628                         ndr->flags = _flags_save_string;
10629                 }
10630                 {
10631                         uint32_t _flags_save_string = ndr->flags;
10632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10633                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10634                         ndr->flags = _flags_save_string;
10635                 }
10636                 {
10637                         uint32_t _flags_save_string = ndr->flags;
10638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10639                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10640                         ndr->flags = _flags_save_string;
10641                 }
10642                 {
10643                         uint32_t _flags_save_string = ndr->flags;
10644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10645                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10646                         ndr->flags = _flags_save_string;
10647                 }
10648                 {
10649                         uint32_t _flags_save_string = ndr->flags;
10650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10652                         ndr->flags = _flags_save_string;
10653                 }
10654                 {
10655                         uint32_t _flags_save_string = ndr->flags;
10656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10657                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10658                         ndr->flags = _flags_save_string;
10659                 }
10660                 {
10661                         uint32_t _flags_save_string_array = ndr->flags;
10662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10663                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10664                         ndr->flags = _flags_save_string_array;
10665                 }
10666                 {
10667                         uint32_t _flags_save_string = ndr->flags;
10668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10669                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10670                         ndr->flags = _flags_save_string;
10671                 }
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->default_datatype));
10676                         ndr->flags = _flags_save_string;
10677                 }
10678                 {
10679                         uint32_t _flags_save_string_array = ndr->flags;
10680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10681                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10682                         ndr->flags = _flags_save_string_array;
10683                 }
10684         }
10685         if (ndr_flags & NDR_BUFFERS) {
10686                 {
10687                         uint32_t _flags_save_string = ndr->flags;
10688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10689                         if (r->driver_name) {
10690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10692                         }
10693                         ndr->flags = _flags_save_string;
10694                 }
10695                 {
10696                         uint32_t _flags_save_string = ndr->flags;
10697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10698                         if (r->architecture) {
10699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10701                         }
10702                         ndr->flags = _flags_save_string;
10703                 }
10704                 {
10705                         uint32_t _flags_save_string = ndr->flags;
10706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10707                         if (r->driver_path) {
10708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10710                         }
10711                         ndr->flags = _flags_save_string;
10712                 }
10713                 {
10714                         uint32_t _flags_save_string = ndr->flags;
10715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10716                         if (r->data_file) {
10717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10719                         }
10720                         ndr->flags = _flags_save_string;
10721                 }
10722                 {
10723                         uint32_t _flags_save_string = ndr->flags;
10724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10725                         if (r->config_file) {
10726                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10727                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10728                         }
10729                         ndr->flags = _flags_save_string;
10730                 }
10731                 {
10732                         uint32_t _flags_save_string = ndr->flags;
10733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10734                         if (r->help_file) {
10735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10737                         }
10738                         ndr->flags = _flags_save_string;
10739                 }
10740                 {
10741                         uint32_t _flags_save_string_array = ndr->flags;
10742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10743                         if (r->dependent_files) {
10744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10745                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10746                         }
10747                         ndr->flags = _flags_save_string_array;
10748                 }
10749                 {
10750                         uint32_t _flags_save_string = ndr->flags;
10751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10752                         if (r->monitor_name) {
10753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10755                         }
10756                         ndr->flags = _flags_save_string;
10757                 }
10758                 {
10759                         uint32_t _flags_save_string = ndr->flags;
10760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10761                         if (r->default_datatype) {
10762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10764                         }
10765                         ndr->flags = _flags_save_string;
10766                 }
10767                 {
10768                         uint32_t _flags_save_string_array = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         if (r->previous_names) {
10771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10772                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10773                         }
10774                         ndr->flags = _flags_save_string_array;
10775                 }
10776         }
10777         return NDR_ERR_SUCCESS;
10778 }
10779
10780 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10781 {
10782         uint32_t _ptr_driver_name;
10783         TALLOC_CTX *_mem_save_driver_name_0;
10784         uint32_t _ptr_architecture;
10785         TALLOC_CTX *_mem_save_architecture_0;
10786         uint32_t _ptr_driver_path;
10787         TALLOC_CTX *_mem_save_driver_path_0;
10788         uint32_t _ptr_data_file;
10789         TALLOC_CTX *_mem_save_data_file_0;
10790         uint32_t _ptr_config_file;
10791         TALLOC_CTX *_mem_save_config_file_0;
10792         uint32_t _ptr_help_file;
10793         TALLOC_CTX *_mem_save_help_file_0;
10794         uint32_t _ptr_dependent_files;
10795         TALLOC_CTX *_mem_save_dependent_files_0;
10796         uint32_t _ptr_monitor_name;
10797         TALLOC_CTX *_mem_save_monitor_name_0;
10798         uint32_t _ptr_default_datatype;
10799         TALLOC_CTX *_mem_save_default_datatype_0;
10800         uint32_t _ptr_previous_names;
10801         TALLOC_CTX *_mem_save_previous_names_0;
10802         if (ndr_flags & NDR_SCALARS) {
10803                 NDR_CHECK(ndr_pull_align(ndr, 4));
10804                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
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_driver_name));
10809                         if (_ptr_driver_name) {
10810                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10812                         } else {
10813                                 r->driver_name = 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_architecture));
10821                         if (_ptr_architecture) {
10822                                 NDR_PULL_ALLOC(ndr, r->architecture);
10823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10824                         } else {
10825                                 r->architecture = NULL;
10826                         }
10827                         ndr->flags = _flags_save_string;
10828                 }
10829                 {
10830                         uint32_t _flags_save_string = ndr->flags;
10831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10832                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10833                         if (_ptr_driver_path) {
10834                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10835                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10836                         } else {
10837                                 r->driver_path = NULL;
10838                         }
10839                         ndr->flags = _flags_save_string;
10840                 }
10841                 {
10842                         uint32_t _flags_save_string = ndr->flags;
10843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10845                         if (_ptr_data_file) {
10846                                 NDR_PULL_ALLOC(ndr, r->data_file);
10847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10848                         } else {
10849                                 r->data_file = NULL;
10850                         }
10851                         ndr->flags = _flags_save_string;
10852                 }
10853                 {
10854                         uint32_t _flags_save_string = ndr->flags;
10855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10857                         if (_ptr_config_file) {
10858                                 NDR_PULL_ALLOC(ndr, r->config_file);
10859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10860                         } else {
10861                                 r->config_file = NULL;
10862                         }
10863                         ndr->flags = _flags_save_string;
10864                 }
10865                 {
10866                         uint32_t _flags_save_string = ndr->flags;
10867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10868                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10869                         if (_ptr_help_file) {
10870                                 NDR_PULL_ALLOC(ndr, r->help_file);
10871                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10872                         } else {
10873                                 r->help_file = NULL;
10874                         }
10875                         ndr->flags = _flags_save_string;
10876                 }
10877                 {
10878                         uint32_t _flags_save_string_array = ndr->flags;
10879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10880                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10881                         if (_ptr_dependent_files) {
10882                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10883                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10884                         } else {
10885                                 r->dependent_files = NULL;
10886                         }
10887                         ndr->flags = _flags_save_string_array;
10888                 }
10889                 {
10890                         uint32_t _flags_save_string = ndr->flags;
10891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10893                         if (_ptr_monitor_name) {
10894                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10896                         } else {
10897                                 r->monitor_name = NULL;
10898                         }
10899                         ndr->flags = _flags_save_string;
10900                 }
10901                 {
10902                         uint32_t _flags_save_string = ndr->flags;
10903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10905                         if (_ptr_default_datatype) {
10906                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10908                         } else {
10909                                 r->default_datatype = NULL;
10910                         }
10911                         ndr->flags = _flags_save_string;
10912                 }
10913                 {
10914                         uint32_t _flags_save_string_array = ndr->flags;
10915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10917                         if (_ptr_previous_names) {
10918                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10920                         } else {
10921                                 r->previous_names = NULL;
10922                         }
10923                         ndr->flags = _flags_save_string_array;
10924                 }
10925         }
10926         if (ndr_flags & NDR_BUFFERS) {
10927                 {
10928                         uint32_t _flags_save_string = ndr->flags;
10929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10930                         if (r->driver_name) {
10931                                 uint32_t _relative_save_offset;
10932                                 _relative_save_offset = ndr->offset;
10933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10934                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10935                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10938                                 ndr->offset = _relative_save_offset;
10939                         }
10940                         ndr->flags = _flags_save_string;
10941                 }
10942                 {
10943                         uint32_t _flags_save_string = ndr->flags;
10944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10945                         if (r->architecture) {
10946                                 uint32_t _relative_save_offset;
10947                                 _relative_save_offset = ndr->offset;
10948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10949                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10953                                 ndr->offset = _relative_save_offset;
10954                         }
10955                         ndr->flags = _flags_save_string;
10956                 }
10957                 {
10958                         uint32_t _flags_save_string = ndr->flags;
10959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10960                         if (r->driver_path) {
10961                                 uint32_t _relative_save_offset;
10962                                 _relative_save_offset = ndr->offset;
10963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10964                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10965                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10966                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10968                                 ndr->offset = _relative_save_offset;
10969                         }
10970                         ndr->flags = _flags_save_string;
10971                 }
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         if (r->data_file) {
10976                                 uint32_t _relative_save_offset;
10977                                 _relative_save_offset = ndr->offset;
10978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10979                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10980                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10981                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10983                                 ndr->offset = _relative_save_offset;
10984                         }
10985                         ndr->flags = _flags_save_string;
10986                 }
10987                 {
10988                         uint32_t _flags_save_string = ndr->flags;
10989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10990                         if (r->config_file) {
10991                                 uint32_t _relative_save_offset;
10992                                 _relative_save_offset = ndr->offset;
10993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10994                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10995                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10998                                 ndr->offset = _relative_save_offset;
10999                         }
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         if (r->help_file) {
11006                                 uint32_t _relative_save_offset;
11007                                 _relative_save_offset = ndr->offset;
11008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11009                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11013                                 ndr->offset = _relative_save_offset;
11014                         }
11015                         ndr->flags = _flags_save_string;
11016                 }
11017                 {
11018                         uint32_t _flags_save_string_array = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         if (r->dependent_files) {
11021                                 uint32_t _relative_save_offset;
11022                                 _relative_save_offset = ndr->offset;
11023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11024                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11025                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11026                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11028                                 ndr->offset = _relative_save_offset;
11029                         }
11030                         ndr->flags = _flags_save_string_array;
11031                 }
11032                 {
11033                         uint32_t _flags_save_string = ndr->flags;
11034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11035                         if (r->monitor_name) {
11036                                 uint32_t _relative_save_offset;
11037                                 _relative_save_offset = ndr->offset;
11038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11039                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11040                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11043                                 ndr->offset = _relative_save_offset;
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->default_datatype) {
11051                                 uint32_t _relative_save_offset;
11052                                 _relative_save_offset = ndr->offset;
11053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11054                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11055                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11058                                 ndr->offset = _relative_save_offset;
11059                         }
11060                         ndr->flags = _flags_save_string;
11061                 }
11062                 {
11063                         uint32_t _flags_save_string_array = ndr->flags;
11064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11065                         if (r->previous_names) {
11066                                 uint32_t _relative_save_offset;
11067                                 _relative_save_offset = ndr->offset;
11068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11069                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11070                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11071                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11073                                 ndr->offset = _relative_save_offset;
11074                         }
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077         }
11078         return NDR_ERR_SUCCESS;
11079 }
11080
11081 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11082 {
11083         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11084         ndr->depth++;
11085         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11086         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11087         ndr->depth++;
11088         if (r->driver_name) {
11089                 ndr_print_string(ndr, "driver_name", r->driver_name);
11090         }
11091         ndr->depth--;
11092         ndr_print_ptr(ndr, "architecture", r->architecture);
11093         ndr->depth++;
11094         if (r->architecture) {
11095                 ndr_print_string(ndr, "architecture", r->architecture);
11096         }
11097         ndr->depth--;
11098         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11099         ndr->depth++;
11100         if (r->driver_path) {
11101                 ndr_print_string(ndr, "driver_path", r->driver_path);
11102         }
11103         ndr->depth--;
11104         ndr_print_ptr(ndr, "data_file", r->data_file);
11105         ndr->depth++;
11106         if (r->data_file) {
11107                 ndr_print_string(ndr, "data_file", r->data_file);
11108         }
11109         ndr->depth--;
11110         ndr_print_ptr(ndr, "config_file", r->config_file);
11111         ndr->depth++;
11112         if (r->config_file) {
11113                 ndr_print_string(ndr, "config_file", r->config_file);
11114         }
11115         ndr->depth--;
11116         ndr_print_ptr(ndr, "help_file", r->help_file);
11117         ndr->depth++;
11118         if (r->help_file) {
11119                 ndr_print_string(ndr, "help_file", r->help_file);
11120         }
11121         ndr->depth--;
11122         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11123         ndr->depth++;
11124         if (r->dependent_files) {
11125                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11126         }
11127         ndr->depth--;
11128         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11129         ndr->depth++;
11130         if (r->monitor_name) {
11131                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11132         }
11133         ndr->depth--;
11134         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11135         ndr->depth++;
11136         if (r->default_datatype) {
11137                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11138         }
11139         ndr->depth--;
11140         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11141         ndr->depth++;
11142         if (r->previous_names) {
11143                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11144         }
11145         ndr->depth--;
11146         ndr->depth--;
11147 }
11148
11149 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11150 {
11151         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11152 }
11153
11154 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11155 {
11156         if (ndr_flags & NDR_SCALARS) {
11157                 NDR_CHECK(ndr_push_align(ndr, 4));
11158                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11159                 {
11160                         uint32_t _flags_save_string = ndr->flags;
11161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11162                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11163                         ndr->flags = _flags_save_string;
11164                 }
11165                 {
11166                         uint32_t _flags_save_string = ndr->flags;
11167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11168                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11169                         ndr->flags = _flags_save_string;
11170                 }
11171                 {
11172                         uint32_t _flags_save_string = ndr->flags;
11173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11174                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11175                         ndr->flags = _flags_save_string;
11176                 }
11177                 {
11178                         uint32_t _flags_save_string = ndr->flags;
11179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11180                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11181                         ndr->flags = _flags_save_string;
11182                 }
11183                 {
11184                         uint32_t _flags_save_string = ndr->flags;
11185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11186                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11187                         ndr->flags = _flags_save_string;
11188                 }
11189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11192         }
11193         if (ndr_flags & NDR_BUFFERS) {
11194                 {
11195                         uint32_t _flags_save_string = ndr->flags;
11196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11197                         if (r->driver_name) {
11198                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11199                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11200                         }
11201                         ndr->flags = _flags_save_string;
11202                 }
11203                 {
11204                         uint32_t _flags_save_string = ndr->flags;
11205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11206                         if (r->architecture) {
11207                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11208                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11209                         }
11210                         ndr->flags = _flags_save_string;
11211                 }
11212                 {
11213                         uint32_t _flags_save_string = ndr->flags;
11214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11215                         if (r->driver_path) {
11216                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11217                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11218                         }
11219                         ndr->flags = _flags_save_string;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         if (r->data_file) {
11225                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11226                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11227                         }
11228                         ndr->flags = _flags_save_string;
11229                 }
11230                 {
11231                         uint32_t _flags_save_string = ndr->flags;
11232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11233                         if (r->config_file) {
11234                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11235                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11236                         }
11237                         ndr->flags = _flags_save_string;
11238                 }
11239         }
11240         return NDR_ERR_SUCCESS;
11241 }
11242
11243 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11244 {
11245         uint32_t _ptr_driver_name;
11246         TALLOC_CTX *_mem_save_driver_name_0;
11247         uint32_t _ptr_architecture;
11248         TALLOC_CTX *_mem_save_architecture_0;
11249         uint32_t _ptr_driver_path;
11250         TALLOC_CTX *_mem_save_driver_path_0;
11251         uint32_t _ptr_data_file;
11252         TALLOC_CTX *_mem_save_data_file_0;
11253         uint32_t _ptr_config_file;
11254         TALLOC_CTX *_mem_save_config_file_0;
11255         if (ndr_flags & NDR_SCALARS) {
11256                 NDR_CHECK(ndr_pull_align(ndr, 4));
11257                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11258                 {
11259                         uint32_t _flags_save_string = ndr->flags;
11260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11262                         if (_ptr_driver_name) {
11263                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11265                         } else {
11266                                 r->driver_name = NULL;
11267                         }
11268                         ndr->flags = _flags_save_string;
11269                 }
11270                 {
11271                         uint32_t _flags_save_string = ndr->flags;
11272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11273                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11274                         if (_ptr_architecture) {
11275                                 NDR_PULL_ALLOC(ndr, r->architecture);
11276                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11277                         } else {
11278                                 r->architecture = NULL;
11279                         }
11280                         ndr->flags = _flags_save_string;
11281                 }
11282                 {
11283                         uint32_t _flags_save_string = ndr->flags;
11284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11285                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11286                         if (_ptr_driver_path) {
11287                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11288                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11289                         } else {
11290                                 r->driver_path = NULL;
11291                         }
11292                         ndr->flags = _flags_save_string;
11293                 }
11294                 {
11295                         uint32_t _flags_save_string = ndr->flags;
11296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11297                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11298                         if (_ptr_data_file) {
11299                                 NDR_PULL_ALLOC(ndr, r->data_file);
11300                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11301                         } else {
11302                                 r->data_file = NULL;
11303                         }
11304                         ndr->flags = _flags_save_string;
11305                 }
11306                 {
11307                         uint32_t _flags_save_string = ndr->flags;
11308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11309                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11310                         if (_ptr_config_file) {
11311                                 NDR_PULL_ALLOC(ndr, r->config_file);
11312                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11313                         } else {
11314                                 r->config_file = NULL;
11315                         }
11316                         ndr->flags = _flags_save_string;
11317                 }
11318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11321         }
11322         if (ndr_flags & NDR_BUFFERS) {
11323                 {
11324                         uint32_t _flags_save_string = ndr->flags;
11325                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11326                         if (r->driver_name) {
11327                                 uint32_t _relative_save_offset;
11328                                 _relative_save_offset = ndr->offset;
11329                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11330                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11331                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11332                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11333                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->architecture) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11345                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11349                                 ndr->offset = _relative_save_offset;
11350                         }
11351                         ndr->flags = _flags_save_string;
11352                 }
11353                 {
11354                         uint32_t _flags_save_string = ndr->flags;
11355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11356                         if (r->driver_path) {
11357                                 uint32_t _relative_save_offset;
11358                                 _relative_save_offset = ndr->offset;
11359                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11360                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11361                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11362                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11363                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11364                                 ndr->offset = _relative_save_offset;
11365                         }
11366                         ndr->flags = _flags_save_string;
11367                 }
11368                 {
11369                         uint32_t _flags_save_string = ndr->flags;
11370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11371                         if (r->data_file) {
11372                                 uint32_t _relative_save_offset;
11373                                 _relative_save_offset = ndr->offset;
11374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11375                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11376                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11379                                 ndr->offset = _relative_save_offset;
11380                         }
11381                         ndr->flags = _flags_save_string;
11382                 }
11383                 {
11384                         uint32_t _flags_save_string = ndr->flags;
11385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11386                         if (r->config_file) {
11387                                 uint32_t _relative_save_offset;
11388                                 _relative_save_offset = ndr->offset;
11389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11390                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11391                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11394                                 ndr->offset = _relative_save_offset;
11395                         }
11396                         ndr->flags = _flags_save_string;
11397                 }
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11403 {
11404         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11405         ndr->depth++;
11406         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11407         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11408         ndr->depth++;
11409         if (r->driver_name) {
11410                 ndr_print_string(ndr, "driver_name", r->driver_name);
11411         }
11412         ndr->depth--;
11413         ndr_print_ptr(ndr, "architecture", r->architecture);
11414         ndr->depth++;
11415         if (r->architecture) {
11416                 ndr_print_string(ndr, "architecture", r->architecture);
11417         }
11418         ndr->depth--;
11419         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11420         ndr->depth++;
11421         if (r->driver_path) {
11422                 ndr_print_string(ndr, "driver_path", r->driver_path);
11423         }
11424         ndr->depth--;
11425         ndr_print_ptr(ndr, "data_file", r->data_file);
11426         ndr->depth++;
11427         if (r->data_file) {
11428                 ndr_print_string(ndr, "data_file", r->data_file);
11429         }
11430         ndr->depth--;
11431         ndr_print_ptr(ndr, "config_file", r->config_file);
11432         ndr->depth++;
11433         if (r->config_file) {
11434                 ndr_print_string(ndr, "config_file", r->config_file);
11435         }
11436         ndr->depth--;
11437         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11438         ndr_print_uint32(ndr, "config_version", r->config_version);
11439         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11440         ndr->depth--;
11441 }
11442
11443 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11444 {
11445         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11446 }
11447
11448 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11449 {
11450         if (ndr_flags & NDR_SCALARS) {
11451                 NDR_CHECK(ndr_push_align(ndr, 8));
11452                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11453                 {
11454                         uint32_t _flags_save_string = ndr->flags;
11455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11456                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11457                         ndr->flags = _flags_save_string;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11463                         ndr->flags = _flags_save_string;
11464                 }
11465                 {
11466                         uint32_t _flags_save_string = ndr->flags;
11467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11468                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11469                         ndr->flags = _flags_save_string;
11470                 }
11471                 {
11472                         uint32_t _flags_save_string = ndr->flags;
11473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11475                         ndr->flags = _flags_save_string;
11476                 }
11477                 {
11478                         uint32_t _flags_save_string = ndr->flags;
11479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11481                         ndr->flags = _flags_save_string;
11482                 }
11483                 {
11484                         uint32_t _flags_save_string = ndr->flags;
11485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11487                         ndr->flags = _flags_save_string;
11488                 }
11489                 {
11490                         uint32_t _flags_save_string_array = ndr->flags;
11491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11493                         ndr->flags = _flags_save_string_array;
11494                 }
11495                 {
11496                         uint32_t _flags_save_string = ndr->flags;
11497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11499                         ndr->flags = _flags_save_string;
11500                 }
11501                 {
11502                         uint32_t _flags_save_string = ndr->flags;
11503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11505                         ndr->flags = _flags_save_string;
11506                 }
11507                 {
11508                         uint32_t _flags_save_string_array = ndr->flags;
11509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11511                         ndr->flags = _flags_save_string_array;
11512                 }
11513                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11514                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11515                 {
11516                         uint32_t _flags_save_string = ndr->flags;
11517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11518                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11519                         ndr->flags = _flags_save_string;
11520                 }
11521                 {
11522                         uint32_t _flags_save_string = ndr->flags;
11523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11525                         ndr->flags = _flags_save_string;
11526                 }
11527                 {
11528                         uint32_t _flags_save_string = ndr->flags;
11529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11530                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11531                         ndr->flags = _flags_save_string;
11532                 }
11533                 {
11534                         uint32_t _flags_save_string = ndr->flags;
11535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11536                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11537                         ndr->flags = _flags_save_string;
11538                 }
11539         }
11540         if (ndr_flags & NDR_BUFFERS) {
11541                 {
11542                         uint32_t _flags_save_string = ndr->flags;
11543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11544                         if (r->driver_name) {
11545                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11546                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11547                         }
11548                         ndr->flags = _flags_save_string;
11549                 }
11550                 {
11551                         uint32_t _flags_save_string = ndr->flags;
11552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11553                         if (r->architecture) {
11554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11556                         }
11557                         ndr->flags = _flags_save_string;
11558                 }
11559                 {
11560                         uint32_t _flags_save_string = ndr->flags;
11561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11562                         if (r->driver_path) {
11563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11565                         }
11566                         ndr->flags = _flags_save_string;
11567                 }
11568                 {
11569                         uint32_t _flags_save_string = ndr->flags;
11570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11571                         if (r->data_file) {
11572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11574                         }
11575                         ndr->flags = _flags_save_string;
11576                 }
11577                 {
11578                         uint32_t _flags_save_string = ndr->flags;
11579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11580                         if (r->config_file) {
11581                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11582                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11583                         }
11584                         ndr->flags = _flags_save_string;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         if (r->help_file) {
11590                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11591                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11592                         }
11593                         ndr->flags = _flags_save_string;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string_array = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         if (r->dependent_files) {
11599                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11600                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11601                         }
11602                         ndr->flags = _flags_save_string_array;
11603                 }
11604                 {
11605                         uint32_t _flags_save_string = ndr->flags;
11606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11607                         if (r->monitor_name) {
11608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11610                         }
11611                         ndr->flags = _flags_save_string;
11612                 }
11613                 {
11614                         uint32_t _flags_save_string = ndr->flags;
11615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11616                         if (r->default_datatype) {
11617                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string_array = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         if (r->previous_names) {
11626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11627                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11628                         }
11629                         ndr->flags = _flags_save_string_array;
11630                 }
11631                 {
11632                         uint32_t _flags_save_string = ndr->flags;
11633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11634                         if (r->manufacturer_name) {
11635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11637                         }
11638                         ndr->flags = _flags_save_string;
11639                 }
11640                 {
11641                         uint32_t _flags_save_string = ndr->flags;
11642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11643                         if (r->manufacturer_url) {
11644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11646                         }
11647                         ndr->flags = _flags_save_string;
11648                 }
11649                 {
11650                         uint32_t _flags_save_string = ndr->flags;
11651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11652                         if (r->hardware_id) {
11653                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11655                         }
11656                         ndr->flags = _flags_save_string;
11657                 }
11658                 {
11659                         uint32_t _flags_save_string = ndr->flags;
11660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11661                         if (r->provider) {
11662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11664                         }
11665                         ndr->flags = _flags_save_string;
11666                 }
11667         }
11668         return NDR_ERR_SUCCESS;
11669 }
11670
11671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11672 {
11673         uint32_t _ptr_driver_name;
11674         TALLOC_CTX *_mem_save_driver_name_0;
11675         uint32_t _ptr_architecture;
11676         TALLOC_CTX *_mem_save_architecture_0;
11677         uint32_t _ptr_driver_path;
11678         TALLOC_CTX *_mem_save_driver_path_0;
11679         uint32_t _ptr_data_file;
11680         TALLOC_CTX *_mem_save_data_file_0;
11681         uint32_t _ptr_config_file;
11682         TALLOC_CTX *_mem_save_config_file_0;
11683         uint32_t _ptr_help_file;
11684         TALLOC_CTX *_mem_save_help_file_0;
11685         uint32_t _ptr_dependent_files;
11686         TALLOC_CTX *_mem_save_dependent_files_0;
11687         uint32_t _ptr_monitor_name;
11688         TALLOC_CTX *_mem_save_monitor_name_0;
11689         uint32_t _ptr_default_datatype;
11690         TALLOC_CTX *_mem_save_default_datatype_0;
11691         uint32_t _ptr_previous_names;
11692         TALLOC_CTX *_mem_save_previous_names_0;
11693         uint32_t _ptr_manufacturer_name;
11694         TALLOC_CTX *_mem_save_manufacturer_name_0;
11695         uint32_t _ptr_manufacturer_url;
11696         TALLOC_CTX *_mem_save_manufacturer_url_0;
11697         uint32_t _ptr_hardware_id;
11698         TALLOC_CTX *_mem_save_hardware_id_0;
11699         uint32_t _ptr_provider;
11700         TALLOC_CTX *_mem_save_provider_0;
11701         if (ndr_flags & NDR_SCALARS) {
11702                 NDR_CHECK(ndr_pull_align(ndr, 8));
11703                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11708                         if (_ptr_driver_name) {
11709                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11711                         } else {
11712                                 r->driver_name = NULL;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11720                         if (_ptr_architecture) {
11721                                 NDR_PULL_ALLOC(ndr, r->architecture);
11722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11723                         } else {
11724                                 r->architecture = NULL;
11725                         }
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11732                         if (_ptr_driver_path) {
11733                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11735                         } else {
11736                                 r->driver_path = NULL;
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11744                         if (_ptr_data_file) {
11745                                 NDR_PULL_ALLOC(ndr, r->data_file);
11746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11747                         } else {
11748                                 r->data_file = NULL;
11749                         }
11750                         ndr->flags = _flags_save_string;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11756                         if (_ptr_config_file) {
11757                                 NDR_PULL_ALLOC(ndr, r->config_file);
11758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11759                         } else {
11760                                 r->config_file = NULL;
11761                         }
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11768                         if (_ptr_help_file) {
11769                                 NDR_PULL_ALLOC(ndr, r->help_file);
11770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11771                         } else {
11772                                 r->help_file = NULL;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string_array = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11780                         if (_ptr_dependent_files) {
11781                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11783                         } else {
11784                                 r->dependent_files = NULL;
11785                         }
11786                         ndr->flags = _flags_save_string_array;
11787                 }
11788                 {
11789                         uint32_t _flags_save_string = ndr->flags;
11790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11792                         if (_ptr_monitor_name) {
11793                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11795                         } else {
11796                                 r->monitor_name = NULL;
11797                         }
11798                         ndr->flags = _flags_save_string;
11799                 }
11800                 {
11801                         uint32_t _flags_save_string = ndr->flags;
11802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11804                         if (_ptr_default_datatype) {
11805                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11807                         } else {
11808                                 r->default_datatype = NULL;
11809                         }
11810                         ndr->flags = _flags_save_string;
11811                 }
11812                 {
11813                         uint32_t _flags_save_string_array = ndr->flags;
11814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11816                         if (_ptr_previous_names) {
11817                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11819                         } else {
11820                                 r->previous_names = NULL;
11821                         }
11822                         ndr->flags = _flags_save_string_array;
11823                 }
11824                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11825                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11826                 {
11827                         uint32_t _flags_save_string = ndr->flags;
11828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11830                         if (_ptr_manufacturer_name) {
11831                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11833                         } else {
11834                                 r->manufacturer_name = NULL;
11835                         }
11836                         ndr->flags = _flags_save_string;
11837                 }
11838                 {
11839                         uint32_t _flags_save_string = ndr->flags;
11840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11842                         if (_ptr_manufacturer_url) {
11843                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11845                         } else {
11846                                 r->manufacturer_url = NULL;
11847                         }
11848                         ndr->flags = _flags_save_string;
11849                 }
11850                 {
11851                         uint32_t _flags_save_string = ndr->flags;
11852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11854                         if (_ptr_hardware_id) {
11855                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11857                         } else {
11858                                 r->hardware_id = NULL;
11859                         }
11860                         ndr->flags = _flags_save_string;
11861                 }
11862                 {
11863                         uint32_t _flags_save_string = ndr->flags;
11864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11866                         if (_ptr_provider) {
11867                                 NDR_PULL_ALLOC(ndr, r->provider);
11868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11869                         } else {
11870                                 r->provider = NULL;
11871                         }
11872                         ndr->flags = _flags_save_string;
11873                 }
11874         }
11875         if (ndr_flags & NDR_BUFFERS) {
11876                 {
11877                         uint32_t _flags_save_string = ndr->flags;
11878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11879                         if (r->driver_name) {
11880                                 uint32_t _relative_save_offset;
11881                                 _relative_save_offset = ndr->offset;
11882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11883                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11884                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11887                                 ndr->offset = _relative_save_offset;
11888                         }
11889                         ndr->flags = _flags_save_string;
11890                 }
11891                 {
11892                         uint32_t _flags_save_string = ndr->flags;
11893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11894                         if (r->architecture) {
11895                                 uint32_t _relative_save_offset;
11896                                 _relative_save_offset = ndr->offset;
11897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11898                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11899                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11902                                 ndr->offset = _relative_save_offset;
11903                         }
11904                         ndr->flags = _flags_save_string;
11905                 }
11906                 {
11907                         uint32_t _flags_save_string = ndr->flags;
11908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11909                         if (r->driver_path) {
11910                                 uint32_t _relative_save_offset;
11911                                 _relative_save_offset = ndr->offset;
11912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11913                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11914                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11917                                 ndr->offset = _relative_save_offset;
11918                         }
11919                         ndr->flags = _flags_save_string;
11920                 }
11921                 {
11922                         uint32_t _flags_save_string = ndr->flags;
11923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11924                         if (r->data_file) {
11925                                 uint32_t _relative_save_offset;
11926                                 _relative_save_offset = ndr->offset;
11927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11928                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11929                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11932                                 ndr->offset = _relative_save_offset;
11933                         }
11934                         ndr->flags = _flags_save_string;
11935                 }
11936                 {
11937                         uint32_t _flags_save_string = ndr->flags;
11938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11939                         if (r->config_file) {
11940                                 uint32_t _relative_save_offset;
11941                                 _relative_save_offset = ndr->offset;
11942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11943                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11944                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11947                                 ndr->offset = _relative_save_offset;
11948                         }
11949                         ndr->flags = _flags_save_string;
11950                 }
11951                 {
11952                         uint32_t _flags_save_string = ndr->flags;
11953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11954                         if (r->help_file) {
11955                                 uint32_t _relative_save_offset;
11956                                 _relative_save_offset = ndr->offset;
11957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11958                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11959                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11962                                 ndr->offset = _relative_save_offset;
11963                         }
11964                         ndr->flags = _flags_save_string;
11965                 }
11966                 {
11967                         uint32_t _flags_save_string_array = ndr->flags;
11968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11969                         if (r->dependent_files) {
11970                                 uint32_t _relative_save_offset;
11971                                 _relative_save_offset = ndr->offset;
11972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11973                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11974                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11975                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11977                                 ndr->offset = _relative_save_offset;
11978                         }
11979                         ndr->flags = _flags_save_string_array;
11980                 }
11981                 {
11982                         uint32_t _flags_save_string = ndr->flags;
11983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11984                         if (r->monitor_name) {
11985                                 uint32_t _relative_save_offset;
11986                                 _relative_save_offset = ndr->offset;
11987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11988                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11990                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11992                                 ndr->offset = _relative_save_offset;
11993                         }
11994                         ndr->flags = _flags_save_string;
11995                 }
11996                 {
11997                         uint32_t _flags_save_string = ndr->flags;
11998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11999                         if (r->default_datatype) {
12000                                 uint32_t _relative_save_offset;
12001                                 _relative_save_offset = ndr->offset;
12002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12003                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12004                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12007                                 ndr->offset = _relative_save_offset;
12008                         }
12009                         ndr->flags = _flags_save_string;
12010                 }
12011                 {
12012                         uint32_t _flags_save_string_array = ndr->flags;
12013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12014                         if (r->previous_names) {
12015                                 uint32_t _relative_save_offset;
12016                                 _relative_save_offset = ndr->offset;
12017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12018                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12019                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12020                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12022                                 ndr->offset = _relative_save_offset;
12023                         }
12024                         ndr->flags = _flags_save_string_array;
12025                 }
12026                 {
12027                         uint32_t _flags_save_string = ndr->flags;
12028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12029                         if (r->manufacturer_name) {
12030                                 uint32_t _relative_save_offset;
12031                                 _relative_save_offset = ndr->offset;
12032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12033                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12034                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12037                                 ndr->offset = _relative_save_offset;
12038                         }
12039                         ndr->flags = _flags_save_string;
12040                 }
12041                 {
12042                         uint32_t _flags_save_string = ndr->flags;
12043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12044                         if (r->manufacturer_url) {
12045                                 uint32_t _relative_save_offset;
12046                                 _relative_save_offset = ndr->offset;
12047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12048                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12049                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12052                                 ndr->offset = _relative_save_offset;
12053                         }
12054                         ndr->flags = _flags_save_string;
12055                 }
12056                 {
12057                         uint32_t _flags_save_string = ndr->flags;
12058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12059                         if (r->hardware_id) {
12060                                 uint32_t _relative_save_offset;
12061                                 _relative_save_offset = ndr->offset;
12062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12063                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12067                                 ndr->offset = _relative_save_offset;
12068                         }
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         if (r->provider) {
12075                                 uint32_t _relative_save_offset;
12076                                 _relative_save_offset = ndr->offset;
12077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12078                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12079                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12082                                 ndr->offset = _relative_save_offset;
12083                         }
12084                         ndr->flags = _flags_save_string;
12085                 }
12086         }
12087         return NDR_ERR_SUCCESS;
12088 }
12089
12090 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12091 {
12092         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12093         ndr->depth++;
12094         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12095         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12096         ndr->depth++;
12097         if (r->driver_name) {
12098                 ndr_print_string(ndr, "driver_name", r->driver_name);
12099         }
12100         ndr->depth--;
12101         ndr_print_ptr(ndr, "architecture", r->architecture);
12102         ndr->depth++;
12103         if (r->architecture) {
12104                 ndr_print_string(ndr, "architecture", r->architecture);
12105         }
12106         ndr->depth--;
12107         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12108         ndr->depth++;
12109         if (r->driver_path) {
12110                 ndr_print_string(ndr, "driver_path", r->driver_path);
12111         }
12112         ndr->depth--;
12113         ndr_print_ptr(ndr, "data_file", r->data_file);
12114         ndr->depth++;
12115         if (r->data_file) {
12116                 ndr_print_string(ndr, "data_file", r->data_file);
12117         }
12118         ndr->depth--;
12119         ndr_print_ptr(ndr, "config_file", r->config_file);
12120         ndr->depth++;
12121         if (r->config_file) {
12122                 ndr_print_string(ndr, "config_file", r->config_file);
12123         }
12124         ndr->depth--;
12125         ndr_print_ptr(ndr, "help_file", r->help_file);
12126         ndr->depth++;
12127         if (r->help_file) {
12128                 ndr_print_string(ndr, "help_file", r->help_file);
12129         }
12130         ndr->depth--;
12131         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12132         ndr->depth++;
12133         if (r->dependent_files) {
12134                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12135         }
12136         ndr->depth--;
12137         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12138         ndr->depth++;
12139         if (r->monitor_name) {
12140                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12141         }
12142         ndr->depth--;
12143         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12144         ndr->depth++;
12145         if (r->default_datatype) {
12146                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12147         }
12148         ndr->depth--;
12149         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12150         ndr->depth++;
12151         if (r->previous_names) {
12152                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12153         }
12154         ndr->depth--;
12155         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12156         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12157         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12158         ndr->depth++;
12159         if (r->manufacturer_name) {
12160                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12161         }
12162         ndr->depth--;
12163         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12164         ndr->depth++;
12165         if (r->manufacturer_url) {
12166                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12167         }
12168         ndr->depth--;
12169         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12170         ndr->depth++;
12171         if (r->hardware_id) {
12172                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12173         }
12174         ndr->depth--;
12175         ndr_print_ptr(ndr, "provider", r->provider);
12176         ndr->depth++;
12177         if (r->provider) {
12178                 ndr_print_string(ndr, "provider", r->provider);
12179         }
12180         ndr->depth--;
12181         ndr->depth--;
12182 }
12183
12184 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12185 {
12186         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12187 }
12188
12189 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12190 {
12191         if (ndr_flags & NDR_SCALARS) {
12192                 NDR_CHECK(ndr_push_align(ndr, 8));
12193                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12194                 {
12195                         uint32_t _flags_save_string = ndr->flags;
12196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12198                         ndr->flags = _flags_save_string;
12199                 }
12200                 {
12201                         uint32_t _flags_save_string = ndr->flags;
12202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12204                         ndr->flags = _flags_save_string;
12205                 }
12206                 {
12207                         uint32_t _flags_save_string = ndr->flags;
12208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12210                         ndr->flags = _flags_save_string;
12211                 }
12212                 {
12213                         uint32_t _flags_save_string = ndr->flags;
12214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12216                         ndr->flags = _flags_save_string;
12217                 }
12218                 {
12219                         uint32_t _flags_save_string = ndr->flags;
12220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12221                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12222                         ndr->flags = _flags_save_string;
12223                 }
12224                 {
12225                         uint32_t _flags_save_string = ndr->flags;
12226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12227                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12228                         ndr->flags = _flags_save_string;
12229                 }
12230                 {
12231                         uint32_t _flags_save_string = ndr->flags;
12232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12233                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12234                         ndr->flags = _flags_save_string;
12235                 }
12236                 {
12237                         uint32_t _flags_save_string = ndr->flags;
12238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12240                         ndr->flags = _flags_save_string;
12241                 }
12242                 {
12243                         uint32_t _flags_save_string_array = ndr->flags;
12244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12246                         ndr->flags = _flags_save_string_array;
12247                 }
12248                 {
12249                         uint32_t _flags_save_string_array = ndr->flags;
12250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12251                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12252                         ndr->flags = _flags_save_string_array;
12253                 }
12254                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12255                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12256                 {
12257                         uint32_t _flags_save_string = ndr->flags;
12258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12260                         ndr->flags = _flags_save_string;
12261                 }
12262                 {
12263                         uint32_t _flags_save_string = ndr->flags;
12264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12266                         ndr->flags = _flags_save_string;
12267                 }
12268                 {
12269                         uint32_t _flags_save_string = ndr->flags;
12270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12271                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12272                         ndr->flags = _flags_save_string;
12273                 }
12274                 {
12275                         uint32_t _flags_save_string = ndr->flags;
12276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12278                         ndr->flags = _flags_save_string;
12279                 }
12280                 {
12281                         uint32_t _flags_save_string = ndr->flags;
12282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12283                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12284                         ndr->flags = _flags_save_string;
12285                 }
12286                 {
12287                         uint32_t _flags_save_string = ndr->flags;
12288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12289                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12290                         ndr->flags = _flags_save_string;
12291                 }
12292                 {
12293                         uint32_t _flags_save_string_array = ndr->flags;
12294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12295                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12296                         ndr->flags = _flags_save_string_array;
12297                 }
12298                 {
12299                         uint32_t _flags_save_string = ndr->flags;
12300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12301                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12302                         ndr->flags = _flags_save_string;
12303                 }
12304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12305                 {
12306                         uint32_t _flags_save_string_array = ndr->flags;
12307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12309                         ndr->flags = _flags_save_string_array;
12310                 }
12311                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12312                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12313         }
12314         if (ndr_flags & NDR_BUFFERS) {
12315                 {
12316                         uint32_t _flags_save_string = ndr->flags;
12317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12318                         if (r->driver_name) {
12319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12321                         }
12322                         ndr->flags = _flags_save_string;
12323                 }
12324                 {
12325                         uint32_t _flags_save_string = ndr->flags;
12326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12327                         if (r->architecture) {
12328                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12330                         }
12331                         ndr->flags = _flags_save_string;
12332                 }
12333                 {
12334                         uint32_t _flags_save_string = ndr->flags;
12335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12336                         if (r->driver_path) {
12337                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12338                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12339                         }
12340                         ndr->flags = _flags_save_string;
12341                 }
12342                 {
12343                         uint32_t _flags_save_string = ndr->flags;
12344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12345                         if (r->data_file) {
12346                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12347                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12348                         }
12349                         ndr->flags = _flags_save_string;
12350                 }
12351                 {
12352                         uint32_t _flags_save_string = ndr->flags;
12353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12354                         if (r->config_file) {
12355                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12356                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12357                         }
12358                         ndr->flags = _flags_save_string;
12359                 }
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         if (r->help_file) {
12364                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12365                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12366                         }
12367                         ndr->flags = _flags_save_string;
12368                 }
12369                 {
12370                         uint32_t _flags_save_string = ndr->flags;
12371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12372                         if (r->monitor_name) {
12373                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12374                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12375                         }
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                         if (r->default_datatype) {
12382                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12384                         }
12385                         ndr->flags = _flags_save_string;
12386                 }
12387                 {
12388                         uint32_t _flags_save_string_array = ndr->flags;
12389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12390                         if (r->dependent_files) {
12391                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12392                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12393                         }
12394                         ndr->flags = _flags_save_string_array;
12395                 }
12396                 {
12397                         uint32_t _flags_save_string_array = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         if (r->previous_names) {
12400                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12401                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12402                         }
12403                         ndr->flags = _flags_save_string_array;
12404                 }
12405                 {
12406                         uint32_t _flags_save_string = ndr->flags;
12407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12408                         if (r->manufacturer_name) {
12409                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12410                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12411                         }
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                         if (r->manufacturer_url) {
12418                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12419                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12420                         }
12421                         ndr->flags = _flags_save_string;
12422                 }
12423                 {
12424                         uint32_t _flags_save_string = ndr->flags;
12425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12426                         if (r->hardware_id) {
12427                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12428                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12429                         }
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         if (r->provider) {
12436                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12437                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12438                         }
12439                         ndr->flags = _flags_save_string;
12440                 }
12441                 {
12442                         uint32_t _flags_save_string = ndr->flags;
12443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12444                         if (r->print_processor) {
12445                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12446                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12447                         }
12448                         ndr->flags = _flags_save_string;
12449                 }
12450                 {
12451                         uint32_t _flags_save_string = ndr->flags;
12452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12453                         if (r->vendor_setup) {
12454                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12455                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12456                         }
12457                         ndr->flags = _flags_save_string;
12458                 }
12459                 {
12460                         uint32_t _flags_save_string_array = ndr->flags;
12461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12462                         if (r->color_profiles) {
12463                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12464                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12465                         }
12466                         ndr->flags = _flags_save_string_array;
12467                 }
12468                 {
12469                         uint32_t _flags_save_string = ndr->flags;
12470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12471                         if (r->inf_path) {
12472                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12473                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12474                         }
12475                         ndr->flags = _flags_save_string;
12476                 }
12477                 {
12478                         uint32_t _flags_save_string_array = ndr->flags;
12479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12480                         if (r->core_driver_dependencies) {
12481                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12482                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12483                         }
12484                         ndr->flags = _flags_save_string_array;
12485                 }
12486         }
12487         return NDR_ERR_SUCCESS;
12488 }
12489
12490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12491 {
12492         uint32_t _ptr_driver_name;
12493         TALLOC_CTX *_mem_save_driver_name_0;
12494         uint32_t _ptr_architecture;
12495         TALLOC_CTX *_mem_save_architecture_0;
12496         uint32_t _ptr_driver_path;
12497         TALLOC_CTX *_mem_save_driver_path_0;
12498         uint32_t _ptr_data_file;
12499         TALLOC_CTX *_mem_save_data_file_0;
12500         uint32_t _ptr_config_file;
12501         TALLOC_CTX *_mem_save_config_file_0;
12502         uint32_t _ptr_help_file;
12503         TALLOC_CTX *_mem_save_help_file_0;
12504         uint32_t _ptr_monitor_name;
12505         TALLOC_CTX *_mem_save_monitor_name_0;
12506         uint32_t _ptr_default_datatype;
12507         TALLOC_CTX *_mem_save_default_datatype_0;
12508         uint32_t _ptr_dependent_files;
12509         TALLOC_CTX *_mem_save_dependent_files_0;
12510         uint32_t _ptr_previous_names;
12511         TALLOC_CTX *_mem_save_previous_names_0;
12512         uint32_t _ptr_manufacturer_name;
12513         TALLOC_CTX *_mem_save_manufacturer_name_0;
12514         uint32_t _ptr_manufacturer_url;
12515         TALLOC_CTX *_mem_save_manufacturer_url_0;
12516         uint32_t _ptr_hardware_id;
12517         TALLOC_CTX *_mem_save_hardware_id_0;
12518         uint32_t _ptr_provider;
12519         TALLOC_CTX *_mem_save_provider_0;
12520         uint32_t _ptr_print_processor;
12521         TALLOC_CTX *_mem_save_print_processor_0;
12522         uint32_t _ptr_vendor_setup;
12523         TALLOC_CTX *_mem_save_vendor_setup_0;
12524         uint32_t _ptr_color_profiles;
12525         TALLOC_CTX *_mem_save_color_profiles_0;
12526         uint32_t _ptr_inf_path;
12527         TALLOC_CTX *_mem_save_inf_path_0;
12528         uint32_t _ptr_core_driver_dependencies;
12529         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12530         if (ndr_flags & NDR_SCALARS) {
12531                 NDR_CHECK(ndr_pull_align(ndr, 8));
12532                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12533                 {
12534                         uint32_t _flags_save_string = ndr->flags;
12535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12536                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12537                         if (_ptr_driver_name) {
12538                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12539                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12540                         } else {
12541                                 r->driver_name = NULL;
12542                         }
12543                         ndr->flags = _flags_save_string;
12544                 }
12545                 {
12546                         uint32_t _flags_save_string = ndr->flags;
12547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12548                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12549                         if (_ptr_architecture) {
12550                                 NDR_PULL_ALLOC(ndr, r->architecture);
12551                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12552                         } else {
12553                                 r->architecture = NULL;
12554                         }
12555                         ndr->flags = _flags_save_string;
12556                 }
12557                 {
12558                         uint32_t _flags_save_string = ndr->flags;
12559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12561                         if (_ptr_driver_path) {
12562                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12564                         } else {
12565                                 r->driver_path = NULL;
12566                         }
12567                         ndr->flags = _flags_save_string;
12568                 }
12569                 {
12570                         uint32_t _flags_save_string = ndr->flags;
12571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12572                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12573                         if (_ptr_data_file) {
12574                                 NDR_PULL_ALLOC(ndr, r->data_file);
12575                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12576                         } else {
12577                                 r->data_file = NULL;
12578                         }
12579                         ndr->flags = _flags_save_string;
12580                 }
12581                 {
12582                         uint32_t _flags_save_string = ndr->flags;
12583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12584                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12585                         if (_ptr_config_file) {
12586                                 NDR_PULL_ALLOC(ndr, r->config_file);
12587                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12588                         } else {
12589                                 r->config_file = NULL;
12590                         }
12591                         ndr->flags = _flags_save_string;
12592                 }
12593                 {
12594                         uint32_t _flags_save_string = ndr->flags;
12595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12596                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12597                         if (_ptr_help_file) {
12598                                 NDR_PULL_ALLOC(ndr, r->help_file);
12599                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12600                         } else {
12601                                 r->help_file = NULL;
12602                         }
12603                         ndr->flags = _flags_save_string;
12604                 }
12605                 {
12606                         uint32_t _flags_save_string = ndr->flags;
12607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12608                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12609                         if (_ptr_monitor_name) {
12610                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12611                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12612                         } else {
12613                                 r->monitor_name = NULL;
12614                         }
12615                         ndr->flags = _flags_save_string;
12616                 }
12617                 {
12618                         uint32_t _flags_save_string = ndr->flags;
12619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12620                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12621                         if (_ptr_default_datatype) {
12622                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12623                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12624                         } else {
12625                                 r->default_datatype = NULL;
12626                         }
12627                         ndr->flags = _flags_save_string;
12628                 }
12629                 {
12630                         uint32_t _flags_save_string_array = ndr->flags;
12631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12632                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12633                         if (_ptr_dependent_files) {
12634                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12635                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12636                         } else {
12637                                 r->dependent_files = NULL;
12638                         }
12639                         ndr->flags = _flags_save_string_array;
12640                 }
12641                 {
12642                         uint32_t _flags_save_string_array = ndr->flags;
12643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12644                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12645                         if (_ptr_previous_names) {
12646                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12647                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12648                         } else {
12649                                 r->previous_names = NULL;
12650                         }
12651                         ndr->flags = _flags_save_string_array;
12652                 }
12653                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12654                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12655                 {
12656                         uint32_t _flags_save_string = ndr->flags;
12657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12658                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12659                         if (_ptr_manufacturer_name) {
12660                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12661                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12662                         } else {
12663                                 r->manufacturer_name = NULL;
12664                         }
12665                         ndr->flags = _flags_save_string;
12666                 }
12667                 {
12668                         uint32_t _flags_save_string = ndr->flags;
12669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12670                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12671                         if (_ptr_manufacturer_url) {
12672                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12673                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12674                         } else {
12675                                 r->manufacturer_url = NULL;
12676                         }
12677                         ndr->flags = _flags_save_string;
12678                 }
12679                 {
12680                         uint32_t _flags_save_string = ndr->flags;
12681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12682                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12683                         if (_ptr_hardware_id) {
12684                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12685                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12686                         } else {
12687                                 r->hardware_id = NULL;
12688                         }
12689                         ndr->flags = _flags_save_string;
12690                 }
12691                 {
12692                         uint32_t _flags_save_string = ndr->flags;
12693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12695                         if (_ptr_provider) {
12696                                 NDR_PULL_ALLOC(ndr, r->provider);
12697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12698                         } else {
12699                                 r->provider = NULL;
12700                         }
12701                         ndr->flags = _flags_save_string;
12702                 }
12703                 {
12704                         uint32_t _flags_save_string = ndr->flags;
12705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12706                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12707                         if (_ptr_print_processor) {
12708                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12709                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12710                         } else {
12711                                 r->print_processor = NULL;
12712                         }
12713                         ndr->flags = _flags_save_string;
12714                 }
12715                 {
12716                         uint32_t _flags_save_string = ndr->flags;
12717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12719                         if (_ptr_vendor_setup) {
12720                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12722                         } else {
12723                                 r->vendor_setup = NULL;
12724                         }
12725                         ndr->flags = _flags_save_string;
12726                 }
12727                 {
12728                         uint32_t _flags_save_string_array = ndr->flags;
12729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12731                         if (_ptr_color_profiles) {
12732                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12734                         } else {
12735                                 r->color_profiles = NULL;
12736                         }
12737                         ndr->flags = _flags_save_string_array;
12738                 }
12739                 {
12740                         uint32_t _flags_save_string = ndr->flags;
12741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12743                         if (_ptr_inf_path) {
12744                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12746                         } else {
12747                                 r->inf_path = NULL;
12748                         }
12749                         ndr->flags = _flags_save_string;
12750                 }
12751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12752                 {
12753                         uint32_t _flags_save_string_array = ndr->flags;
12754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12756                         if (_ptr_core_driver_dependencies) {
12757                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12759                         } else {
12760                                 r->core_driver_dependencies = NULL;
12761                         }
12762                         ndr->flags = _flags_save_string_array;
12763                 }
12764                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12765                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12766         }
12767         if (ndr_flags & NDR_BUFFERS) {
12768                 {
12769                         uint32_t _flags_save_string = ndr->flags;
12770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12771                         if (r->driver_name) {
12772                                 uint32_t _relative_save_offset;
12773                                 _relative_save_offset = ndr->offset;
12774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12775                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12776                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12779                                 ndr->offset = _relative_save_offset;
12780                         }
12781                         ndr->flags = _flags_save_string;
12782                 }
12783                 {
12784                         uint32_t _flags_save_string = ndr->flags;
12785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12786                         if (r->architecture) {
12787                                 uint32_t _relative_save_offset;
12788                                 _relative_save_offset = ndr->offset;
12789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12790                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12791                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12794                                 ndr->offset = _relative_save_offset;
12795                         }
12796                         ndr->flags = _flags_save_string;
12797                 }
12798                 {
12799                         uint32_t _flags_save_string = ndr->flags;
12800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12801                         if (r->driver_path) {
12802                                 uint32_t _relative_save_offset;
12803                                 _relative_save_offset = ndr->offset;
12804                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12805                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12806                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12807                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12808                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12809                                 ndr->offset = _relative_save_offset;
12810                         }
12811                         ndr->flags = _flags_save_string;
12812                 }
12813                 {
12814                         uint32_t _flags_save_string = ndr->flags;
12815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12816                         if (r->data_file) {
12817                                 uint32_t _relative_save_offset;
12818                                 _relative_save_offset = ndr->offset;
12819                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12820                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12821                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12822                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12823                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12824                                 ndr->offset = _relative_save_offset;
12825                         }
12826                         ndr->flags = _flags_save_string;
12827                 }
12828                 {
12829                         uint32_t _flags_save_string = ndr->flags;
12830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12831                         if (r->config_file) {
12832                                 uint32_t _relative_save_offset;
12833                                 _relative_save_offset = ndr->offset;
12834                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12835                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12836                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12837                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12838                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->help_file) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12850                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12854                                 ndr->offset = _relative_save_offset;
12855                         }
12856                         ndr->flags = _flags_save_string;
12857                 }
12858                 {
12859                         uint32_t _flags_save_string = ndr->flags;
12860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12861                         if (r->monitor_name) {
12862                                 uint32_t _relative_save_offset;
12863                                 _relative_save_offset = ndr->offset;
12864                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12865                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12866                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12867                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12868                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12869                                 ndr->offset = _relative_save_offset;
12870                         }
12871                         ndr->flags = _flags_save_string;
12872                 }
12873                 {
12874                         uint32_t _flags_save_string = ndr->flags;
12875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12876                         if (r->default_datatype) {
12877                                 uint32_t _relative_save_offset;
12878                                 _relative_save_offset = ndr->offset;
12879                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12880                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12881                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12882                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12883                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12884                                 ndr->offset = _relative_save_offset;
12885                         }
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string_array = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         if (r->dependent_files) {
12892                                 uint32_t _relative_save_offset;
12893                                 _relative_save_offset = ndr->offset;
12894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12895                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12896                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12897                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12899                                 ndr->offset = _relative_save_offset;
12900                         }
12901                         ndr->flags = _flags_save_string_array;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string_array = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->previous_names) {
12907                                 uint32_t _relative_save_offset;
12908                                 _relative_save_offset = ndr->offset;
12909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12910                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12912                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12914                                 ndr->offset = _relative_save_offset;
12915                         }
12916                         ndr->flags = _flags_save_string_array;
12917                 }
12918                 {
12919                         uint32_t _flags_save_string = ndr->flags;
12920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12921                         if (r->manufacturer_name) {
12922                                 uint32_t _relative_save_offset;
12923                                 _relative_save_offset = ndr->offset;
12924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12925                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12926                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->manufacturer_url) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12940                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12942                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12944                                 ndr->offset = _relative_save_offset;
12945                         }
12946                         ndr->flags = _flags_save_string;
12947                 }
12948                 {
12949                         uint32_t _flags_save_string = ndr->flags;
12950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12951                         if (r->hardware_id) {
12952                                 uint32_t _relative_save_offset;
12953                                 _relative_save_offset = ndr->offset;
12954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12955                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12956                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12959                                 ndr->offset = _relative_save_offset;
12960                         }
12961                         ndr->flags = _flags_save_string;
12962                 }
12963                 {
12964                         uint32_t _flags_save_string = ndr->flags;
12965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12966                         if (r->provider) {
12967                                 uint32_t _relative_save_offset;
12968                                 _relative_save_offset = ndr->offset;
12969                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12970                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12971                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12972                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12973                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12974                                 ndr->offset = _relative_save_offset;
12975                         }
12976                         ndr->flags = _flags_save_string;
12977                 }
12978                 {
12979                         uint32_t _flags_save_string = ndr->flags;
12980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12981                         if (r->print_processor) {
12982                                 uint32_t _relative_save_offset;
12983                                 _relative_save_offset = ndr->offset;
12984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
12985                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
12986                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
12987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
12988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
12989                                 ndr->offset = _relative_save_offset;
12990                         }
12991                         ndr->flags = _flags_save_string;
12992                 }
12993                 {
12994                         uint32_t _flags_save_string = ndr->flags;
12995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12996                         if (r->vendor_setup) {
12997                                 uint32_t _relative_save_offset;
12998                                 _relative_save_offset = ndr->offset;
12999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13000                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13004                                 ndr->offset = _relative_save_offset;
13005                         }
13006                         ndr->flags = _flags_save_string;
13007                 }
13008                 {
13009                         uint32_t _flags_save_string_array = ndr->flags;
13010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13011                         if (r->color_profiles) {
13012                                 uint32_t _relative_save_offset;
13013                                 _relative_save_offset = ndr->offset;
13014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13015                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13016                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13017                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string_array;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->inf_path) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13030                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13034                                 ndr->offset = _relative_save_offset;
13035                         }
13036                         ndr->flags = _flags_save_string;
13037                 }
13038                 {
13039                         uint32_t _flags_save_string_array = ndr->flags;
13040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13041                         if (r->core_driver_dependencies) {
13042                                 uint32_t _relative_save_offset;
13043                                 _relative_save_offset = ndr->offset;
13044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13045                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13046                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13047                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13049                                 ndr->offset = _relative_save_offset;
13050                         }
13051                         ndr->flags = _flags_save_string_array;
13052                 }
13053         }
13054         return NDR_ERR_SUCCESS;
13055 }
13056
13057 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13058 {
13059         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13060         ndr->depth++;
13061         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13062         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13063         ndr->depth++;
13064         if (r->driver_name) {
13065                 ndr_print_string(ndr, "driver_name", r->driver_name);
13066         }
13067         ndr->depth--;
13068         ndr_print_ptr(ndr, "architecture", r->architecture);
13069         ndr->depth++;
13070         if (r->architecture) {
13071                 ndr_print_string(ndr, "architecture", r->architecture);
13072         }
13073         ndr->depth--;
13074         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13075         ndr->depth++;
13076         if (r->driver_path) {
13077                 ndr_print_string(ndr, "driver_path", r->driver_path);
13078         }
13079         ndr->depth--;
13080         ndr_print_ptr(ndr, "data_file", r->data_file);
13081         ndr->depth++;
13082         if (r->data_file) {
13083                 ndr_print_string(ndr, "data_file", r->data_file);
13084         }
13085         ndr->depth--;
13086         ndr_print_ptr(ndr, "config_file", r->config_file);
13087         ndr->depth++;
13088         if (r->config_file) {
13089                 ndr_print_string(ndr, "config_file", r->config_file);
13090         }
13091         ndr->depth--;
13092         ndr_print_ptr(ndr, "help_file", r->help_file);
13093         ndr->depth++;
13094         if (r->help_file) {
13095                 ndr_print_string(ndr, "help_file", r->help_file);
13096         }
13097         ndr->depth--;
13098         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13099         ndr->depth++;
13100         if (r->monitor_name) {
13101                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13102         }
13103         ndr->depth--;
13104         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13105         ndr->depth++;
13106         if (r->default_datatype) {
13107                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13108         }
13109         ndr->depth--;
13110         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13111         ndr->depth++;
13112         if (r->dependent_files) {
13113                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13114         }
13115         ndr->depth--;
13116         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13117         ndr->depth++;
13118         if (r->previous_names) {
13119                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13120         }
13121         ndr->depth--;
13122         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13123         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13124         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13125         ndr->depth++;
13126         if (r->manufacturer_name) {
13127                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13128         }
13129         ndr->depth--;
13130         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13131         ndr->depth++;
13132         if (r->manufacturer_url) {
13133                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13134         }
13135         ndr->depth--;
13136         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13137         ndr->depth++;
13138         if (r->hardware_id) {
13139                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13140         }
13141         ndr->depth--;
13142         ndr_print_ptr(ndr, "provider", r->provider);
13143         ndr->depth++;
13144         if (r->provider) {
13145                 ndr_print_string(ndr, "provider", r->provider);
13146         }
13147         ndr->depth--;
13148         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13149         ndr->depth++;
13150         if (r->print_processor) {
13151                 ndr_print_string(ndr, "print_processor", r->print_processor);
13152         }
13153         ndr->depth--;
13154         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13155         ndr->depth++;
13156         if (r->vendor_setup) {
13157                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13158         }
13159         ndr->depth--;
13160         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13161         ndr->depth++;
13162         if (r->color_profiles) {
13163                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13164         }
13165         ndr->depth--;
13166         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13167         ndr->depth++;
13168         if (r->inf_path) {
13169                 ndr_print_string(ndr, "inf_path", r->inf_path);
13170         }
13171         ndr->depth--;
13172         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13173         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13174         ndr->depth++;
13175         if (r->core_driver_dependencies) {
13176                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13177         }
13178         ndr->depth--;
13179         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13180         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13181         ndr->depth--;
13182 }
13183
13184 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13185 {
13186         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13187 }
13188
13189 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13190 {
13191         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13192         return NDR_ERR_SUCCESS;
13193 }
13194
13195 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13196 {
13197         uint32_t v;
13198         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13199         *r = v;
13200         return NDR_ERR_SUCCESS;
13201 }
13202
13203 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13204 {
13205         const char *val = NULL;
13206
13207         switch (r) {
13208                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13209                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13210                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13211                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13212                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13213         }
13214         ndr_print_enum(ndr, name, "ENUM", val, r);
13215 }
13216
13217 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13218 {
13219         if (ndr_flags & NDR_SCALARS) {
13220                 NDR_CHECK(ndr_push_align(ndr, 4));
13221                 {
13222                         uint32_t _flags_save_string = ndr->flags;
13223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13224                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13225                         ndr->flags = _flags_save_string;
13226                 }
13227                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13229         }
13230         if (ndr_flags & NDR_BUFFERS) {
13231                 {
13232                         uint32_t _flags_save_string = ndr->flags;
13233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13234                         if (r->file_name) {
13235                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13236                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13237                         }
13238                         ndr->flags = _flags_save_string;
13239                 }
13240         }
13241         return NDR_ERR_SUCCESS;
13242 }
13243
13244 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13245 {
13246         uint32_t _ptr_file_name;
13247         TALLOC_CTX *_mem_save_file_name_0;
13248         if (ndr_flags & NDR_SCALARS) {
13249                 NDR_CHECK(ndr_pull_align(ndr, 4));
13250                 {
13251                         uint32_t _flags_save_string = ndr->flags;
13252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13253                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13254                         if (_ptr_file_name) {
13255                                 NDR_PULL_ALLOC(ndr, r->file_name);
13256                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13257                         } else {
13258                                 r->file_name = NULL;
13259                         }
13260                         ndr->flags = _flags_save_string;
13261                 }
13262                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13264         }
13265         if (ndr_flags & NDR_BUFFERS) {
13266                 {
13267                         uint32_t _flags_save_string = ndr->flags;
13268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13269                         if (r->file_name) {
13270                                 uint32_t _relative_save_offset;
13271                                 _relative_save_offset = ndr->offset;
13272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13273                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13274                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13277                                 ndr->offset = _relative_save_offset;
13278                         }
13279                         ndr->flags = _flags_save_string;
13280                 }
13281         }
13282         return NDR_ERR_SUCCESS;
13283 }
13284
13285 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13286 {
13287         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13288         ndr->depth++;
13289         ndr_print_ptr(ndr, "file_name", r->file_name);
13290         ndr->depth++;
13291         if (r->file_name) {
13292                 ndr_print_string(ndr, "file_name", r->file_name);
13293         }
13294         ndr->depth--;
13295         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13296         ndr_print_uint32(ndr, "file_version", r->file_version);
13297         ndr->depth--;
13298 }
13299
13300 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13301 {
13302         uint32_t cntr_file_info_1;
13303         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13304         ndr->depth++;
13305         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13306         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13307         ndr->depth++;
13308         if (r->driver_name) {
13309                 ndr_print_string(ndr, "driver_name", r->driver_name);
13310         }
13311         ndr->depth--;
13312         ndr_print_ptr(ndr, "architecture", r->architecture);
13313         ndr->depth++;
13314         if (r->architecture) {
13315                 ndr_print_string(ndr, "architecture", r->architecture);
13316         }
13317         ndr->depth--;
13318         ndr_print_ptr(ndr, "file_info", r->file_info);
13319         ndr->depth++;
13320         if (r->file_info) {
13321                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13322                 ndr->depth++;
13323                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13324                         char *idx_1=NULL;
13325                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13326                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13327                                 free(idx_1);
13328                         }
13329                 }
13330                 ndr->depth--;
13331         }
13332         ndr->depth--;
13333         ndr_print_uint32(ndr, "file_count", r->file_count);
13334         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13335         ndr->depth++;
13336         if (r->monitor_name) {
13337                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13338         }
13339         ndr->depth--;
13340         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13341         ndr->depth++;
13342         if (r->default_datatype) {
13343                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13344         }
13345         ndr->depth--;
13346         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13347         ndr->depth++;
13348         if (r->previous_names) {
13349                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13350         }
13351         ndr->depth--;
13352         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13353         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13354         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13355         ndr->depth++;
13356         if (r->manufacturer_name) {
13357                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13358         }
13359         ndr->depth--;
13360         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13361         ndr->depth++;
13362         if (r->manufacturer_url) {
13363                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13364         }
13365         ndr->depth--;
13366         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13367         ndr->depth++;
13368         if (r->hardware_id) {
13369                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13370         }
13371         ndr->depth--;
13372         ndr_print_ptr(ndr, "provider", r->provider);
13373         ndr->depth++;
13374         if (r->provider) {
13375                 ndr_print_string(ndr, "provider", r->provider);
13376         }
13377         ndr->depth--;
13378         ndr->depth--;
13379 }
13380
13381 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13382 {
13383         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13384 }
13385
13386 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13387 {
13388         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13389         if (ndr_flags & NDR_SCALARS) {
13390                 int level = ndr_push_get_switch_value(ndr, r);
13391                 switch (level) {
13392                         case 1: {
13393                                 NDR_CHECK(ndr_push_align(ndr, 4));
13394                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13395                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13396                         break; }
13397
13398                         case 2: {
13399                                 NDR_CHECK(ndr_push_align(ndr, 4));
13400                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13401                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13402                         break; }
13403
13404                         case 3: {
13405                                 NDR_CHECK(ndr_push_align(ndr, 4));
13406                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13407                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13408                         break; }
13409
13410                         case 4: {
13411                                 NDR_CHECK(ndr_push_align(ndr, 4));
13412                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13413                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13414                         break; }
13415
13416                         case 5: {
13417                                 NDR_CHECK(ndr_push_align(ndr, 4));
13418                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13419                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13420                         break; }
13421
13422                         case 6: {
13423                                 NDR_CHECK(ndr_push_align(ndr, 8));
13424                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13425                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13426                         break; }
13427
13428                         case 8: {
13429                                 NDR_CHECK(ndr_push_align(ndr, 8));
13430                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13431                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13432                         break; }
13433
13434                         case 101: {
13435                                 NDR_CHECK(ndr_push_align(ndr, 8));
13436                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13437                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13438                         break; }
13439
13440                         default: {
13441                         break; }
13442
13443                 }
13444         }
13445         if (ndr_flags & NDR_BUFFERS) {
13446                 int level = ndr_push_get_switch_value(ndr, r);
13447                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13448                 switch (level) {
13449                         case 1:
13450                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13451                         break;
13452
13453                         case 2:
13454                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13455                         break;
13456
13457                         case 3:
13458                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13459                         break;
13460
13461                         case 4:
13462                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13463                         break;
13464
13465                         case 5:
13466                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13467                         break;
13468
13469                         case 6:
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13471                         break;
13472
13473                         case 8:
13474                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13475                         break;
13476
13477                         case 101:
13478                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13479                         break;
13480
13481                         default:
13482                         break;
13483
13484                 }
13485         }
13486         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13487         return NDR_ERR_SUCCESS;
13488 }
13489
13490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13491 {
13492         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13493         int level;
13494         level = ndr_pull_get_switch_value(ndr, r);
13495         if (ndr_flags & NDR_SCALARS) {
13496                 switch (level) {
13497                         case 1: {
13498                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13499                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13500                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13501                         break; }
13502
13503                         case 2: {
13504                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13505                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13506                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13507                         break; }
13508
13509                         case 3: {
13510                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13511                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13512                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13513                         break; }
13514
13515                         case 4: {
13516                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13517                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13518                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13519                         break; }
13520
13521                         case 5: {
13522                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13523                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13524                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13525                         break; }
13526
13527                         case 6: {
13528                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13529                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13530                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13531                         break; }
13532
13533                         case 8: {
13534                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13535                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13536                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13537                         break; }
13538
13539                         case 101: {
13540                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13541                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13542                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13543                         break; }
13544
13545                         default: {
13546                         break; }
13547
13548                 }
13549         }
13550         if (ndr_flags & NDR_BUFFERS) {
13551                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13552                 switch (level) {
13553                         case 1:
13554                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13555                         break;
13556
13557                         case 2:
13558                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13559                         break;
13560
13561                         case 3:
13562                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13563                         break;
13564
13565                         case 4:
13566                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13567                         break;
13568
13569                         case 5:
13570                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13571                         break;
13572
13573                         case 6:
13574                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13575                         break;
13576
13577                         case 8:
13578                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13579                         break;
13580
13581                         case 101:
13582                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13583                         break;
13584
13585                         default:
13586                         break;
13587
13588                 }
13589         }
13590         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13591         return NDR_ERR_SUCCESS;
13592 }
13593
13594 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13595 {
13596         int level;
13597         level = ndr_print_get_switch_value(ndr, r);
13598         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13599         switch (level) {
13600                 case 1:
13601                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13602                 break;
13603
13604                 case 2:
13605                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13606                 break;
13607
13608                 case 3:
13609                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13610                 break;
13611
13612                 case 4:
13613                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13614                 break;
13615
13616                 case 5:
13617                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13618                 break;
13619
13620                 case 6:
13621                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13622                 break;
13623
13624                 case 8:
13625                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13626                 break;
13627
13628                 case 101:
13629                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13630                 break;
13631
13632                 default:
13633                 break;
13634
13635         }
13636 }
13637
13638 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13639 {
13640         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13641 }
13642
13643 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13644 {
13645         if (ndr_flags & NDR_SCALARS) {
13646                 NDR_CHECK(ndr_push_align(ndr, 4));
13647                 {
13648                         uint32_t _flags_save_string = ndr->flags;
13649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13650                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13651                         ndr->flags = _flags_save_string;
13652                 }
13653         }
13654         if (ndr_flags & NDR_BUFFERS) {
13655         }
13656         return NDR_ERR_SUCCESS;
13657 }
13658
13659 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13660 {
13661         if (ndr_flags & NDR_SCALARS) {
13662                 NDR_CHECK(ndr_pull_align(ndr, 4));
13663                 {
13664                         uint32_t _flags_save_string = ndr->flags;
13665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13666                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13667                         ndr->flags = _flags_save_string;
13668                 }
13669         }
13670         if (ndr_flags & NDR_BUFFERS) {
13671         }
13672         return NDR_ERR_SUCCESS;
13673 }
13674
13675 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13676 {
13677         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13678         ndr->depth++;
13679         ndr_print_string(ndr, "directory_name", r->directory_name);
13680         ndr->depth--;
13681 }
13682
13683 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13684 {
13685         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13686 }
13687
13688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13689 {
13690         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13691         if (ndr_flags & NDR_SCALARS) {
13692                 int level = ndr_push_get_switch_value(ndr, r);
13693                 switch (level) {
13694                         case 1: {
13695                                 NDR_CHECK(ndr_push_align(ndr, 4));
13696                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13697                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13698                         break; }
13699
13700                         default: {
13701                                 NDR_CHECK(ndr_push_align(ndr, 4));
13702                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13703                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13704                         break; }
13705
13706                 }
13707         }
13708         if (ndr_flags & NDR_BUFFERS) {
13709                 int level = ndr_push_get_switch_value(ndr, r);
13710                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13711                 switch (level) {
13712                         case 1:
13713                         break;
13714
13715                         default:
13716                         break;
13717
13718                 }
13719         }
13720         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13721         return NDR_ERR_SUCCESS;
13722 }
13723
13724 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13725 {
13726         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13727         int level;
13728         level = ndr_pull_get_switch_value(ndr, r);
13729         if (ndr_flags & NDR_SCALARS) {
13730                 switch (level) {
13731                         case 1: {
13732                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13733                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13734                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13735                         break; }
13736
13737                         default: {
13738                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13739                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13740                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13741                         break; }
13742
13743                 }
13744         }
13745         if (ndr_flags & NDR_BUFFERS) {
13746                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13747                 switch (level) {
13748                         case 1:
13749                         break;
13750
13751                         default:
13752                         break;
13753
13754                 }
13755         }
13756         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13757         return NDR_ERR_SUCCESS;
13758 }
13759
13760 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13761 {
13762         int level;
13763         level = ndr_print_get_switch_value(ndr, r);
13764         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13765         switch (level) {
13766                 case 1:
13767                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13768                 break;
13769
13770                 default:
13771                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13772                 break;
13773
13774         }
13775 }
13776
13777 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13778 {
13779         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13780 }
13781
13782 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13783 {
13784         if (ndr_flags & NDR_SCALARS) {
13785                 NDR_CHECK(ndr_push_align(ndr, 4));
13786                 {
13787                         uint32_t _flags_save_string = ndr->flags;
13788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13789                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13790                         ndr->flags = _flags_save_string;
13791                 }
13792         }
13793         if (ndr_flags & NDR_BUFFERS) {
13794                 {
13795                         uint32_t _flags_save_string = ndr->flags;
13796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13797                         if (r->print_processor_name) {
13798                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13799                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13800                         }
13801                         ndr->flags = _flags_save_string;
13802                 }
13803         }
13804         return NDR_ERR_SUCCESS;
13805 }
13806
13807 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13808 {
13809         uint32_t _ptr_print_processor_name;
13810         TALLOC_CTX *_mem_save_print_processor_name_0;
13811         if (ndr_flags & NDR_SCALARS) {
13812                 NDR_CHECK(ndr_pull_align(ndr, 4));
13813                 {
13814                         uint32_t _flags_save_string = ndr->flags;
13815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13817                         if (_ptr_print_processor_name) {
13818                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13820                         } else {
13821                                 r->print_processor_name = NULL;
13822                         }
13823                         ndr->flags = _flags_save_string;
13824                 }
13825         }
13826         if (ndr_flags & NDR_BUFFERS) {
13827                 {
13828                         uint32_t _flags_save_string = ndr->flags;
13829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13830                         if (r->print_processor_name) {
13831                                 uint32_t _relative_save_offset;
13832                                 _relative_save_offset = ndr->offset;
13833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13834                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13835                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13838                                 ndr->offset = _relative_save_offset;
13839                         }
13840                         ndr->flags = _flags_save_string;
13841                 }
13842         }
13843         return NDR_ERR_SUCCESS;
13844 }
13845
13846 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13847 {
13848         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13849         ndr->depth++;
13850         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13851         ndr->depth++;
13852         if (r->print_processor_name) {
13853                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13854         }
13855         ndr->depth--;
13856         ndr->depth--;
13857 }
13858
13859 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13860 {
13861         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13862 }
13863
13864 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13865 {
13866         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13867         if (ndr_flags & NDR_SCALARS) {
13868                 int level = ndr_push_get_switch_value(ndr, r);
13869                 switch (level) {
13870                         case 1: {
13871                                 NDR_CHECK(ndr_push_align(ndr, 4));
13872                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13873                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13874                         break; }
13875
13876                         default: {
13877                         break; }
13878
13879                 }
13880         }
13881         if (ndr_flags & NDR_BUFFERS) {
13882                 int level = ndr_push_get_switch_value(ndr, r);
13883                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13884                 switch (level) {
13885                         case 1:
13886                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13887                         break;
13888
13889                         default:
13890                         break;
13891
13892                 }
13893         }
13894         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13895         return NDR_ERR_SUCCESS;
13896 }
13897
13898 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13899 {
13900         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13901         int level;
13902         level = ndr_pull_get_switch_value(ndr, r);
13903         if (ndr_flags & NDR_SCALARS) {
13904                 switch (level) {
13905                         case 1: {
13906                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13907                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13908                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13909                         break; }
13910
13911                         default: {
13912                         break; }
13913
13914                 }
13915         }
13916         if (ndr_flags & NDR_BUFFERS) {
13917                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13918                 switch (level) {
13919                         case 1:
13920                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13921                         break;
13922
13923                         default:
13924                         break;
13925
13926                 }
13927         }
13928         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13929         return NDR_ERR_SUCCESS;
13930 }
13931
13932 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13933 {
13934         int level;
13935         level = ndr_print_get_switch_value(ndr, r);
13936         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13937         switch (level) {
13938                 case 1:
13939                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13940                 break;
13941
13942                 default:
13943                 break;
13944
13945         }
13946 }
13947
13948 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13949 {
13950         if (ndr_flags & NDR_SCALARS) {
13951                 NDR_CHECK(ndr_push_align(ndr, 4));
13952                 {
13953                         uint32_t _flags_save_string = ndr->flags;
13954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13955                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13956                         ndr->flags = _flags_save_string;
13957                 }
13958         }
13959         if (ndr_flags & NDR_BUFFERS) {
13960         }
13961         return NDR_ERR_SUCCESS;
13962 }
13963
13964 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
13965 {
13966         if (ndr_flags & NDR_SCALARS) {
13967                 NDR_CHECK(ndr_pull_align(ndr, 4));
13968                 {
13969                         uint32_t _flags_save_string = ndr->flags;
13970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13971                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13972                         ndr->flags = _flags_save_string;
13973                 }
13974         }
13975         if (ndr_flags & NDR_BUFFERS) {
13976         }
13977         return NDR_ERR_SUCCESS;
13978 }
13979
13980 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13981 {
13982         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
13983         ndr->depth++;
13984         ndr_print_string(ndr, "directory_name", r->directory_name);
13985         ndr->depth--;
13986 }
13987
13988 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13989 {
13990         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
13991 }
13992
13993 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
13994 {
13995         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13996         if (ndr_flags & NDR_SCALARS) {
13997                 int level = ndr_push_get_switch_value(ndr, r);
13998                 switch (level) {
13999                         case 1: {
14000                                 NDR_CHECK(ndr_push_align(ndr, 4));
14001                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14002                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14003                         break; }
14004
14005                         default: {
14006                                 NDR_CHECK(ndr_push_align(ndr, 4));
14007                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14008                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14009                         break; }
14010
14011                 }
14012         }
14013         if (ndr_flags & NDR_BUFFERS) {
14014                 int level = ndr_push_get_switch_value(ndr, r);
14015                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14016                 switch (level) {
14017                         case 1:
14018                         break;
14019
14020                         default:
14021                         break;
14022
14023                 }
14024         }
14025         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14026         return NDR_ERR_SUCCESS;
14027 }
14028
14029 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14030 {
14031         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14032         int level;
14033         level = ndr_pull_get_switch_value(ndr, r);
14034         if (ndr_flags & NDR_SCALARS) {
14035                 switch (level) {
14036                         case 1: {
14037                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14038                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14039                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14040                         break; }
14041
14042                         default: {
14043                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14044                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14045                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14046                         break; }
14047
14048                 }
14049         }
14050         if (ndr_flags & NDR_BUFFERS) {
14051                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14052                 switch (level) {
14053                         case 1:
14054                         break;
14055
14056                         default:
14057                         break;
14058
14059                 }
14060         }
14061         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14062         return NDR_ERR_SUCCESS;
14063 }
14064
14065 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14066 {
14067         int level;
14068         level = ndr_print_get_switch_value(ndr, r);
14069         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14070         switch (level) {
14071                 case 1:
14072                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14073                 break;
14074
14075                 default:
14076                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14077                 break;
14078
14079         }
14080 }
14081
14082 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14083 {
14084         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14085 }
14086
14087 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14088 {
14089         if (ndr_flags & NDR_SCALARS) {
14090                 NDR_CHECK(ndr_push_align(ndr, 4));
14091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14094         }
14095         if (ndr_flags & NDR_BUFFERS) {
14096                 if (r->document_name) {
14097                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14101                 }
14102                 if (r->output_file) {
14103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14107                 }
14108                 if (r->datatype) {
14109                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14112                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14113                 }
14114         }
14115         return NDR_ERR_SUCCESS;
14116 }
14117
14118 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14119 {
14120         uint32_t _ptr_document_name;
14121         TALLOC_CTX *_mem_save_document_name_0;
14122         uint32_t _ptr_output_file;
14123         TALLOC_CTX *_mem_save_output_file_0;
14124         uint32_t _ptr_datatype;
14125         TALLOC_CTX *_mem_save_datatype_0;
14126         if (ndr_flags & NDR_SCALARS) {
14127                 NDR_CHECK(ndr_pull_align(ndr, 4));
14128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14129                 if (_ptr_document_name) {
14130                         NDR_PULL_ALLOC(ndr, r->document_name);
14131                 } else {
14132                         r->document_name = NULL;
14133                 }
14134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14135                 if (_ptr_output_file) {
14136                         NDR_PULL_ALLOC(ndr, r->output_file);
14137                 } else {
14138                         r->output_file = NULL;
14139                 }
14140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14141                 if (_ptr_datatype) {
14142                         NDR_PULL_ALLOC(ndr, r->datatype);
14143                 } else {
14144                         r->datatype = NULL;
14145                 }
14146         }
14147         if (ndr_flags & NDR_BUFFERS) {
14148                 if (r->document_name) {
14149                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14150                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14153                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14154                                 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));
14155                         }
14156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14159                 }
14160                 if (r->output_file) {
14161                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14162                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14165                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14166                                 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));
14167                         }
14168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14171                 }
14172                 if (r->datatype) {
14173                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14174                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14177                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14178                                 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));
14179                         }
14180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14183                 }
14184         }
14185         return NDR_ERR_SUCCESS;
14186 }
14187
14188 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14189 {
14190         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14191         ndr->depth++;
14192         ndr_print_ptr(ndr, "document_name", r->document_name);
14193         ndr->depth++;
14194         if (r->document_name) {
14195                 ndr_print_string(ndr, "document_name", r->document_name);
14196         }
14197         ndr->depth--;
14198         ndr_print_ptr(ndr, "output_file", r->output_file);
14199         ndr->depth++;
14200         if (r->output_file) {
14201                 ndr_print_string(ndr, "output_file", r->output_file);
14202         }
14203         ndr->depth--;
14204         ndr_print_ptr(ndr, "datatype", r->datatype);
14205         ndr->depth++;
14206         if (r->datatype) {
14207                 ndr_print_string(ndr, "datatype", r->datatype);
14208         }
14209         ndr->depth--;
14210         ndr->depth--;
14211 }
14212
14213 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14214 {
14215         if (ndr_flags & NDR_SCALARS) {
14216                 int level = ndr_push_get_switch_value(ndr, r);
14217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14218                 switch (level) {
14219                         case 1: {
14220                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14221                         break; }
14222
14223                         case 2: {
14224                         break; }
14225
14226                         case 3: {
14227                         break; }
14228
14229                         default: {
14230                         break; }
14231
14232                 }
14233         }
14234         if (ndr_flags & NDR_BUFFERS) {
14235                 int level = ndr_push_get_switch_value(ndr, r);
14236                 switch (level) {
14237                         case 1:
14238                                 if (r->info1) {
14239                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14240                                 }
14241                         break;
14242
14243                         case 2:
14244                         break;
14245
14246                         case 3:
14247                         break;
14248
14249                         default:
14250                         break;
14251
14252                 }
14253         }
14254         return NDR_ERR_SUCCESS;
14255 }
14256
14257 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14258 {
14259         int level;
14260         uint32_t _level;
14261         TALLOC_CTX *_mem_save_info1_0;
14262         level = ndr_pull_get_switch_value(ndr, r);
14263         if (ndr_flags & NDR_SCALARS) {
14264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14265                 if (_level != level) {
14266                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14267                 }
14268                 switch (level) {
14269                         case 1: {
14270                                 uint32_t _ptr_info1;
14271                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14272                                 if (_ptr_info1) {
14273                                         NDR_PULL_ALLOC(ndr, r->info1);
14274                                 } else {
14275                                         r->info1 = NULL;
14276                                 }
14277                         break; }
14278
14279                         case 2: {
14280                         break; }
14281
14282                         case 3: {
14283                         break; }
14284
14285                         default: {
14286                         break; }
14287
14288                 }
14289         }
14290         if (ndr_flags & NDR_BUFFERS) {
14291                 switch (level) {
14292                         case 1:
14293                                 if (r->info1) {
14294                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14295                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14296                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14297                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14298                                 }
14299                         break;
14300
14301                         case 2:
14302                         break;
14303
14304                         case 3:
14305                         break;
14306
14307                         default:
14308                         break;
14309
14310                 }
14311         }
14312         return NDR_ERR_SUCCESS;
14313 }
14314
14315 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14316 {
14317         int level;
14318         level = ndr_print_get_switch_value(ndr, r);
14319         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14320         switch (level) {
14321                 case 1:
14322                         ndr_print_ptr(ndr, "info1", r->info1);
14323                         ndr->depth++;
14324                         if (r->info1) {
14325                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14326                         }
14327                         ndr->depth--;
14328                 break;
14329
14330                 case 2:
14331                 break;
14332
14333                 case 3:
14334                 break;
14335
14336                 default:
14337                 break;
14338
14339         }
14340 }
14341
14342 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14343 {
14344         if (ndr_flags & NDR_SCALARS) {
14345                 NDR_CHECK(ndr_push_align(ndr, 4));
14346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14351                 {
14352                         uint32_t _flags_save_string = ndr->flags;
14353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14354                         {
14355                                 struct ndr_push *_ndr_extra_string;
14356                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14357                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14358                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14359                         }
14360                         ndr->flags = _flags_save_string;
14361                 }
14362         }
14363         if (ndr_flags & NDR_BUFFERS) {
14364         }
14365         return NDR_ERR_SUCCESS;
14366 }
14367
14368 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14369 {
14370         if (ndr_flags & NDR_SCALARS) {
14371                 NDR_CHECK(ndr_pull_align(ndr, 4));
14372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14377                 {
14378                         uint32_t _flags_save_string = ndr->flags;
14379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14380                         {
14381                                 struct ndr_pull *_ndr_extra_string;
14382                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14383                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14384                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14385                         }
14386                         ndr->flags = _flags_save_string;
14387                 }
14388         }
14389         if (ndr_flags & NDR_BUFFERS) {
14390         }
14391         return NDR_ERR_SUCCESS;
14392 }
14393
14394 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14395 {
14396         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14397         ndr->depth++;
14398         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);
14399         ndr_print_uint32(ndr, "major", r->major);
14400         ndr_print_uint32(ndr, "minor", r->minor);
14401         ndr_print_uint32(ndr, "build", r->build);
14402         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14403         ndr_print_string(ndr, "extra_string", r->extra_string);
14404         ndr->depth--;
14405 }
14406
14407 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14408 {
14409         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14410 }
14411
14412 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14413 {
14414         if (ndr_flags & NDR_SCALARS) {
14415                 NDR_CHECK(ndr_push_align(ndr, 4));
14416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14421                 {
14422                         uint32_t _flags_save_string = ndr->flags;
14423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14424                         {
14425                                 struct ndr_push *_ndr_extra_string;
14426                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14427                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14428                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14429                         }
14430                         ndr->flags = _flags_save_string;
14431                 }
14432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14434         }
14435         if (ndr_flags & NDR_BUFFERS) {
14436         }
14437         return NDR_ERR_SUCCESS;
14438 }
14439
14440 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14441 {
14442         if (ndr_flags & NDR_SCALARS) {
14443                 NDR_CHECK(ndr_pull_align(ndr, 4));
14444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14449                 {
14450                         uint32_t _flags_save_string = ndr->flags;
14451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14452                         {
14453                                 struct ndr_pull *_ndr_extra_string;
14454                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14455                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14456                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14457                         }
14458                         ndr->flags = _flags_save_string;
14459                 }
14460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14462         }
14463         if (ndr_flags & NDR_BUFFERS) {
14464         }
14465         return NDR_ERR_SUCCESS;
14466 }
14467
14468 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14469 {
14470         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14471         ndr->depth++;
14472         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);
14473         ndr_print_uint32(ndr, "major", r->major);
14474         ndr_print_uint32(ndr, "minor", r->minor);
14475         ndr_print_uint32(ndr, "build", r->build);
14476         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14477         ndr_print_string(ndr, "extra_string", r->extra_string);
14478         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14479         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14480         ndr->depth--;
14481 }
14482
14483 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14484 {
14485         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14486 }
14487
14488 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14489 {
14490         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14491         return NDR_ERR_SUCCESS;
14492 }
14493
14494 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14495 {
14496         uint32_t v;
14497         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14498         *r = v;
14499         return NDR_ERR_SUCCESS;
14500 }
14501
14502 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14503 {
14504         const char *val = NULL;
14505
14506         switch (r) {
14507                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14508                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14509                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14510                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14511                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14512         }
14513         ndr_print_enum(ndr, name, "ENUM", val, r);
14514 }
14515
14516 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14517 {
14518         if (ndr_flags & NDR_SCALARS) {
14519                 int level = ndr_push_get_switch_value(ndr, r);
14520                 switch (level) {
14521                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14522                         break; }
14523
14524                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14525                                 {
14526                                         uint32_t _flags_save_string = ndr->flags;
14527                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14528                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14529                                         ndr->flags = _flags_save_string;
14530                                 }
14531                         break; }
14532
14533                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14534                                 {
14535                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14536                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14537                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14538                                         ndr->flags = _flags_save_DATA_BLOB;
14539                                 }
14540                         break; }
14541
14542                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14543                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14544                         break; }
14545
14546                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14547                                 {
14548                                         uint32_t _flags_save_string_array = ndr->flags;
14549                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14550                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14551                                         ndr->flags = _flags_save_string_array;
14552                                 }
14553                         break; }
14554
14555                         default: {
14556                                 {
14557                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14558                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14559                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14560                                         ndr->flags = _flags_save_DATA_BLOB;
14561                                 }
14562                         break; }
14563
14564                 }
14565         }
14566         if (ndr_flags & NDR_BUFFERS) {
14567                 int level = ndr_push_get_switch_value(ndr, r);
14568                 switch (level) {
14569                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14570                         break;
14571
14572                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14573                         break;
14574
14575                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14576                         break;
14577
14578                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14579                         break;
14580
14581                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14582                         break;
14583
14584                         default:
14585                         break;
14586
14587                 }
14588         }
14589         return NDR_ERR_SUCCESS;
14590 }
14591
14592 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14593 {
14594         int level;
14595         level = ndr_pull_get_switch_value(ndr, r);
14596         if (ndr_flags & NDR_SCALARS) {
14597                 switch (level) {
14598                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14599                         break; }
14600
14601                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14602                                 {
14603                                         uint32_t _flags_save_string = ndr->flags;
14604                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14605                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14606                                         ndr->flags = _flags_save_string;
14607                                 }
14608                         break; }
14609
14610                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14611                                 {
14612                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14613                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14614                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14615                                         ndr->flags = _flags_save_DATA_BLOB;
14616                                 }
14617                         break; }
14618
14619                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14620                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14621                         break; }
14622
14623                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14624                                 {
14625                                         uint32_t _flags_save_string_array = ndr->flags;
14626                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14627                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14628                                         ndr->flags = _flags_save_string_array;
14629                                 }
14630                         break; }
14631
14632                         default: {
14633                                 {
14634                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14635                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14636                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14637                                         ndr->flags = _flags_save_DATA_BLOB;
14638                                 }
14639                         break; }
14640
14641                 }
14642         }
14643         if (ndr_flags & NDR_BUFFERS) {
14644                 switch (level) {
14645                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14646                         break;
14647
14648                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14649                         break;
14650
14651                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14652                         break;
14653
14654                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14655                         break;
14656
14657                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14658                         break;
14659
14660                         default:
14661                         break;
14662
14663                 }
14664         }
14665         return NDR_ERR_SUCCESS;
14666 }
14667
14668 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14669 {
14670         int level;
14671         level = ndr_print_get_switch_value(ndr, r);
14672         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14673         switch (level) {
14674                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14675                 break;
14676
14677                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14678                         ndr_print_string(ndr, "string", r->string);
14679                 break;
14680
14681                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14682                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14683                 break;
14684
14685                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14686                         ndr_print_uint32(ndr, "value", r->value);
14687                 break;
14688
14689                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14690                         ndr_print_string_array(ndr, "string_array", r->string_array);
14691                 break;
14692
14693                 default:
14694                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14695                 break;
14696
14697         }
14698 }
14699
14700 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14701 {
14702         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14703 }
14704
14705 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14706 {
14707         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14708         return NDR_ERR_SUCCESS;
14709 }
14710
14711 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14712 {
14713         uint32_t v;
14714         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14715         *r = v;
14716         return NDR_ERR_SUCCESS;
14717 }
14718
14719 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14720 {
14721         const char *val = NULL;
14722
14723         switch (r) {
14724                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14725                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14726                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14727         }
14728         ndr_print_enum(ndr, name, "ENUM", val, r);
14729 }
14730
14731 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14732 {
14733         if (ndr_flags & NDR_SCALARS) {
14734                 NDR_CHECK(ndr_push_align(ndr, 4));
14735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14737         }
14738         if (ndr_flags & NDR_BUFFERS) {
14739         }
14740         return NDR_ERR_SUCCESS;
14741 }
14742
14743 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14744 {
14745         if (ndr_flags & NDR_SCALARS) {
14746                 NDR_CHECK(ndr_pull_align(ndr, 4));
14747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14749         }
14750         if (ndr_flags & NDR_BUFFERS) {
14751         }
14752         return NDR_ERR_SUCCESS;
14753 }
14754
14755 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14756 {
14757         ndr_print_struct(ndr, name, "spoolss_FormSize");
14758         ndr->depth++;
14759         ndr_print_uint32(ndr, "width", r->width);
14760         ndr_print_uint32(ndr, "height", r->height);
14761         ndr->depth--;
14762 }
14763
14764 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14765 {
14766         if (ndr_flags & NDR_SCALARS) {
14767                 NDR_CHECK(ndr_push_align(ndr, 4));
14768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14772         }
14773         if (ndr_flags & NDR_BUFFERS) {
14774         }
14775         return NDR_ERR_SUCCESS;
14776 }
14777
14778 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14779 {
14780         if (ndr_flags & NDR_SCALARS) {
14781                 NDR_CHECK(ndr_pull_align(ndr, 4));
14782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14785                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14786         }
14787         if (ndr_flags & NDR_BUFFERS) {
14788         }
14789         return NDR_ERR_SUCCESS;
14790 }
14791
14792 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14793 {
14794         ndr_print_struct(ndr, name, "spoolss_FormArea");
14795         ndr->depth++;
14796         ndr_print_uint32(ndr, "left", r->left);
14797         ndr_print_uint32(ndr, "top", r->top);
14798         ndr_print_uint32(ndr, "right", r->right);
14799         ndr_print_uint32(ndr, "bottom", r->bottom);
14800         ndr->depth--;
14801 }
14802
14803 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14804 {
14805         if (ndr_flags & NDR_SCALARS) {
14806                 NDR_CHECK(ndr_push_align(ndr, 4));
14807                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14808                 {
14809                         uint32_t _flags_save_string = ndr->flags;
14810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14811                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14812                         ndr->flags = _flags_save_string;
14813                 }
14814                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14815                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14816         }
14817         if (ndr_flags & NDR_BUFFERS) {
14818                 {
14819                         uint32_t _flags_save_string = ndr->flags;
14820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14821                         if (r->form_name) {
14822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14823                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14824                         }
14825                         ndr->flags = _flags_save_string;
14826                 }
14827         }
14828         return NDR_ERR_SUCCESS;
14829 }
14830
14831 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14832 {
14833         uint32_t _ptr_form_name;
14834         TALLOC_CTX *_mem_save_form_name_0;
14835         if (ndr_flags & NDR_SCALARS) {
14836                 NDR_CHECK(ndr_pull_align(ndr, 4));
14837                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14838                 {
14839                         uint32_t _flags_save_string = ndr->flags;
14840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14842                         if (_ptr_form_name) {
14843                                 NDR_PULL_ALLOC(ndr, r->form_name);
14844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14845                         } else {
14846                                 r->form_name = NULL;
14847                         }
14848                         ndr->flags = _flags_save_string;
14849                 }
14850                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14851                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14852         }
14853         if (ndr_flags & NDR_BUFFERS) {
14854                 {
14855                         uint32_t _flags_save_string = ndr->flags;
14856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14857                         if (r->form_name) {
14858                                 uint32_t _relative_save_offset;
14859                                 _relative_save_offset = ndr->offset;
14860                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14861                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14862                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14863                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14864                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14865                                 ndr->offset = _relative_save_offset;
14866                         }
14867                         ndr->flags = _flags_save_string;
14868                 }
14869         }
14870         return NDR_ERR_SUCCESS;
14871 }
14872
14873 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14874 {
14875         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14876         ndr->depth++;
14877         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14878         ndr_print_ptr(ndr, "form_name", r->form_name);
14879         ndr->depth++;
14880         if (r->form_name) {
14881                 ndr_print_string(ndr, "form_name", r->form_name);
14882         }
14883         ndr->depth--;
14884         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14885         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14886         ndr->depth--;
14887 }
14888
14889 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14890 {
14891         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14892 }
14893
14894 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14895 {
14896         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14897         return NDR_ERR_SUCCESS;
14898 }
14899
14900 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14901 {
14902         uint32_t v;
14903         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14904         *r = v;
14905         return NDR_ERR_SUCCESS;
14906 }
14907
14908 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14909 {
14910         ndr_print_uint32(ndr, name, r);
14911         ndr->depth++;
14912         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14915         ndr->depth--;
14916 }
14917
14918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14919 {
14920         if (ndr_flags & NDR_SCALARS) {
14921                 NDR_CHECK(ndr_push_align(ndr, 4));
14922                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14923                 {
14924                         uint32_t _flags_save_string = ndr->flags;
14925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14927                         ndr->flags = _flags_save_string;
14928                 }
14929                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14930                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14931                 {
14932                         uint32_t _flags_save_string = ndr->flags;
14933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14934                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14935                         ndr->flags = _flags_save_string;
14936                 }
14937                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14938                 {
14939                         uint32_t _flags_save_string = ndr->flags;
14940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14941                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14942                         ndr->flags = _flags_save_string;
14943                 }
14944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14945                 {
14946                         uint32_t _flags_save_string = ndr->flags;
14947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14949                         ndr->flags = _flags_save_string;
14950                 }
14951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14952         }
14953         if (ndr_flags & NDR_BUFFERS) {
14954                 {
14955                         uint32_t _flags_save_string = ndr->flags;
14956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14957                         if (r->form_name) {
14958                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14959                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14960                         }
14961                         ndr->flags = _flags_save_string;
14962                 }
14963                 {
14964                         uint32_t _flags_save_string = ndr->flags;
14965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14966                         if (r->keyword) {
14967                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14968                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14969                         }
14970                         ndr->flags = _flags_save_string;
14971                 }
14972                 {
14973                         uint32_t _flags_save_string = ndr->flags;
14974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14975                         if (r->mui_dll) {
14976                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14977                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14978                         }
14979                         ndr->flags = _flags_save_string;
14980                 }
14981                 {
14982                         uint32_t _flags_save_string = ndr->flags;
14983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14984                         if (r->display_name) {
14985                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
14986                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
14987                         }
14988                         ndr->flags = _flags_save_string;
14989                 }
14990         }
14991         return NDR_ERR_SUCCESS;
14992 }
14993
14994 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
14995 {
14996         uint32_t _ptr_form_name;
14997         TALLOC_CTX *_mem_save_form_name_0;
14998         uint32_t _ptr_keyword;
14999         TALLOC_CTX *_mem_save_keyword_0;
15000         uint32_t _ptr_mui_dll;
15001         TALLOC_CTX *_mem_save_mui_dll_0;
15002         uint32_t _ptr_display_name;
15003         TALLOC_CTX *_mem_save_display_name_0;
15004         if (ndr_flags & NDR_SCALARS) {
15005                 NDR_CHECK(ndr_pull_align(ndr, 4));
15006                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15007                 {
15008                         uint32_t _flags_save_string = ndr->flags;
15009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15010                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15011                         if (_ptr_form_name) {
15012                                 NDR_PULL_ALLOC(ndr, r->form_name);
15013                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15014                         } else {
15015                                 r->form_name = NULL;
15016                         }
15017                         ndr->flags = _flags_save_string;
15018                 }
15019                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15020                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15021                 {
15022                         uint32_t _flags_save_string = ndr->flags;
15023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15025                         if (_ptr_keyword) {
15026                                 NDR_PULL_ALLOC(ndr, r->keyword);
15027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15028                         } else {
15029                                 r->keyword = NULL;
15030                         }
15031                         ndr->flags = _flags_save_string;
15032                 }
15033                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15034                 {
15035                         uint32_t _flags_save_string = ndr->flags;
15036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15037                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15038                         if (_ptr_mui_dll) {
15039                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15040                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15041                         } else {
15042                                 r->mui_dll = NULL;
15043                         }
15044                         ndr->flags = _flags_save_string;
15045                 }
15046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15047                 {
15048                         uint32_t _flags_save_string = ndr->flags;
15049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15050                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15051                         if (_ptr_display_name) {
15052                                 NDR_PULL_ALLOC(ndr, r->display_name);
15053                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15054                         } else {
15055                                 r->display_name = NULL;
15056                         }
15057                         ndr->flags = _flags_save_string;
15058                 }
15059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15060         }
15061         if (ndr_flags & NDR_BUFFERS) {
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15065                         if (r->form_name) {
15066                                 uint32_t _relative_save_offset;
15067                                 _relative_save_offset = ndr->offset;
15068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15069                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15070                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15073                                 ndr->offset = _relative_save_offset;
15074                         }
15075                         ndr->flags = _flags_save_string;
15076                 }
15077                 {
15078                         uint32_t _flags_save_string = ndr->flags;
15079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15080                         if (r->keyword) {
15081                                 uint32_t _relative_save_offset;
15082                                 _relative_save_offset = ndr->offset;
15083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15084                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15088                                 ndr->offset = _relative_save_offset;
15089                         }
15090                         ndr->flags = _flags_save_string;
15091                 }
15092                 {
15093                         uint32_t _flags_save_string = ndr->flags;
15094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15095                         if (r->mui_dll) {
15096                                 uint32_t _relative_save_offset;
15097                                 _relative_save_offset = ndr->offset;
15098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15099                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15100                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15103                                 ndr->offset = _relative_save_offset;
15104                         }
15105                         ndr->flags = _flags_save_string;
15106                 }
15107                 {
15108                         uint32_t _flags_save_string = ndr->flags;
15109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15110                         if (r->display_name) {
15111                                 uint32_t _relative_save_offset;
15112                                 _relative_save_offset = ndr->offset;
15113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15114                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15115                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15116                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15118                                 ndr->offset = _relative_save_offset;
15119                         }
15120                         ndr->flags = _flags_save_string;
15121                 }
15122         }
15123         return NDR_ERR_SUCCESS;
15124 }
15125
15126 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15127 {
15128         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15129         ndr->depth++;
15130         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15131         ndr_print_ptr(ndr, "form_name", r->form_name);
15132         ndr->depth++;
15133         if (r->form_name) {
15134                 ndr_print_string(ndr, "form_name", r->form_name);
15135         }
15136         ndr->depth--;
15137         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15138         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15139         ndr_print_ptr(ndr, "keyword", r->keyword);
15140         ndr->depth++;
15141         if (r->keyword) {
15142                 ndr_print_string(ndr, "keyword", r->keyword);
15143         }
15144         ndr->depth--;
15145         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15146         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15147         ndr->depth++;
15148         if (r->mui_dll) {
15149                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15150         }
15151         ndr->depth--;
15152         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15153         ndr_print_ptr(ndr, "display_name", r->display_name);
15154         ndr->depth++;
15155         if (r->display_name) {
15156                 ndr_print_string(ndr, "display_name", r->display_name);
15157         }
15158         ndr->depth--;
15159         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15160         ndr->depth--;
15161 }
15162
15163 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15164 {
15165         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15166 }
15167
15168 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15169 {
15170         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15171         if (ndr_flags & NDR_SCALARS) {
15172                 int level = ndr_push_get_switch_value(ndr, r);
15173                 switch (level) {
15174                         case 1: {
15175                                 NDR_CHECK(ndr_push_align(ndr, 4));
15176                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15177                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15178                         break; }
15179
15180                         case 2: {
15181                                 NDR_CHECK(ndr_push_align(ndr, 4));
15182                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15183                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15184                         break; }
15185
15186                         default: {
15187                         break; }
15188
15189                 }
15190         }
15191         if (ndr_flags & NDR_BUFFERS) {
15192                 int level = ndr_push_get_switch_value(ndr, r);
15193                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15194                 switch (level) {
15195                         case 1:
15196                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15197                         break;
15198
15199                         case 2:
15200                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15201                         break;
15202
15203                         default:
15204                         break;
15205
15206                 }
15207         }
15208         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15209         return NDR_ERR_SUCCESS;
15210 }
15211
15212 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15213 {
15214         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15215         int level;
15216         level = ndr_pull_get_switch_value(ndr, r);
15217         if (ndr_flags & NDR_SCALARS) {
15218                 switch (level) {
15219                         case 1: {
15220                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15221                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15222                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15223                         break; }
15224
15225                         case 2: {
15226                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15227                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15228                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15229                         break; }
15230
15231                         default: {
15232                         break; }
15233
15234                 }
15235         }
15236         if (ndr_flags & NDR_BUFFERS) {
15237                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15238                 switch (level) {
15239                         case 1:
15240                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15241                         break;
15242
15243                         case 2:
15244                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15245                         break;
15246
15247                         default:
15248                         break;
15249
15250                 }
15251         }
15252         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15253         return NDR_ERR_SUCCESS;
15254 }
15255
15256 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15257 {
15258         int level;
15259         level = ndr_print_get_switch_value(ndr, r);
15260         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15261         switch (level) {
15262                 case 1:
15263                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15264                 break;
15265
15266                 case 2:
15267                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15268                 break;
15269
15270                 default:
15271                 break;
15272
15273         }
15274 }
15275
15276 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15277 {
15278         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15279 }
15280
15281 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15282 {
15283         if (ndr_flags & NDR_SCALARS) {
15284                 NDR_CHECK(ndr_push_align(ndr, 4));
15285                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15286                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15287                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15288                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15289         }
15290         if (ndr_flags & NDR_BUFFERS) {
15291                 if (r->form_name) {
15292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15293                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15294                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15296                 }
15297         }
15298         return NDR_ERR_SUCCESS;
15299 }
15300
15301 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15302 {
15303         uint32_t _ptr_form_name;
15304         TALLOC_CTX *_mem_save_form_name_0;
15305         if (ndr_flags & NDR_SCALARS) {
15306                 NDR_CHECK(ndr_pull_align(ndr, 4));
15307                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15309                 if (_ptr_form_name) {
15310                         NDR_PULL_ALLOC(ndr, r->form_name);
15311                 } else {
15312                         r->form_name = NULL;
15313                 }
15314                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15315                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15316         }
15317         if (ndr_flags & NDR_BUFFERS) {
15318                 if (r->form_name) {
15319                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15320                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15323                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15324                                 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));
15325                         }
15326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15329                 }
15330         }
15331         return NDR_ERR_SUCCESS;
15332 }
15333
15334 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15335 {
15336         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15337         ndr->depth++;
15338         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15339         ndr_print_ptr(ndr, "form_name", r->form_name);
15340         ndr->depth++;
15341         if (r->form_name) {
15342                 ndr_print_string(ndr, "form_name", r->form_name);
15343         }
15344         ndr->depth--;
15345         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15346         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15347         ndr->depth--;
15348 }
15349
15350 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15351 {
15352         if (ndr_flags & NDR_SCALARS) {
15353                 NDR_CHECK(ndr_push_align(ndr, 4));
15354                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15356                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15357                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15359                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15364         }
15365         if (ndr_flags & NDR_BUFFERS) {
15366                 if (r->form_name) {
15367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15371                 }
15372                 if (r->keyword) {
15373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15377                 }
15378                 if (r->mui_dll) {
15379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15383                 }
15384                 if (r->display_name) {
15385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15389                 }
15390         }
15391         return NDR_ERR_SUCCESS;
15392 }
15393
15394 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15395 {
15396         uint32_t _ptr_form_name;
15397         TALLOC_CTX *_mem_save_form_name_0;
15398         uint32_t _ptr_keyword;
15399         TALLOC_CTX *_mem_save_keyword_0;
15400         uint32_t _ptr_mui_dll;
15401         TALLOC_CTX *_mem_save_mui_dll_0;
15402         uint32_t _ptr_display_name;
15403         TALLOC_CTX *_mem_save_display_name_0;
15404         if (ndr_flags & NDR_SCALARS) {
15405                 NDR_CHECK(ndr_pull_align(ndr, 4));
15406                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15408                 if (_ptr_form_name) {
15409                         NDR_PULL_ALLOC(ndr, r->form_name);
15410                 } else {
15411                         r->form_name = NULL;
15412                 }
15413                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15414                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15415                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15416                 if (_ptr_keyword) {
15417                         NDR_PULL_ALLOC(ndr, r->keyword);
15418                 } else {
15419                         r->keyword = NULL;
15420                 }
15421                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15423                 if (_ptr_mui_dll) {
15424                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15425                 } else {
15426                         r->mui_dll = NULL;
15427                 }
15428                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15430                 if (_ptr_display_name) {
15431                         NDR_PULL_ALLOC(ndr, r->display_name);
15432                 } else {
15433                         r->display_name = NULL;
15434                 }
15435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15436         }
15437         if (ndr_flags & NDR_BUFFERS) {
15438                 if (r->form_name) {
15439                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15440                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15441                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15442                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15443                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15444                                 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));
15445                         }
15446                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15447                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15448                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15449                 }
15450                 if (r->keyword) {
15451                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15452                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15453                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15454                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15455                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15456                                 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));
15457                         }
15458                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15459                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15461                 }
15462                 if (r->mui_dll) {
15463                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15464                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15465                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15466                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15467                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15468                                 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));
15469                         }
15470                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15471                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15473                 }
15474                 if (r->display_name) {
15475                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15476                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15477                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15478                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15479                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15480                                 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));
15481                         }
15482                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15483                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15485                 }
15486         }
15487         return NDR_ERR_SUCCESS;
15488 }
15489
15490 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15491 {
15492         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15493         ndr->depth++;
15494         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15495         ndr_print_ptr(ndr, "form_name", r->form_name);
15496         ndr->depth++;
15497         if (r->form_name) {
15498                 ndr_print_string(ndr, "form_name", r->form_name);
15499         }
15500         ndr->depth--;
15501         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15502         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15503         ndr_print_ptr(ndr, "keyword", r->keyword);
15504         ndr->depth++;
15505         if (r->keyword) {
15506                 ndr_print_string(ndr, "keyword", r->keyword);
15507         }
15508         ndr->depth--;
15509         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15510         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15511         ndr->depth++;
15512         if (r->mui_dll) {
15513                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15514         }
15515         ndr->depth--;
15516         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15517         ndr_print_ptr(ndr, "display_name", r->display_name);
15518         ndr->depth++;
15519         if (r->display_name) {
15520                 ndr_print_string(ndr, "display_name", r->display_name);
15521         }
15522         ndr->depth--;
15523         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15524         ndr->depth--;
15525 }
15526
15527 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15528 {
15529         if (ndr_flags & NDR_SCALARS) {
15530                 int level = ndr_push_get_switch_value(ndr, r);
15531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15532                 switch (level) {
15533                         case 1: {
15534                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15535                         break; }
15536
15537                         case 2: {
15538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15539                         break; }
15540
15541                         default:
15542                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15543                 }
15544         }
15545         if (ndr_flags & NDR_BUFFERS) {
15546                 int level = ndr_push_get_switch_value(ndr, r);
15547                 switch (level) {
15548                         case 1:
15549                                 if (r->info1) {
15550                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15551                                 }
15552                         break;
15553
15554                         case 2:
15555                                 if (r->info2) {
15556                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15557                                 }
15558                         break;
15559
15560                         default:
15561                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15562                 }
15563         }
15564         return NDR_ERR_SUCCESS;
15565 }
15566
15567 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15568 {
15569         int level;
15570         uint32_t _level;
15571         TALLOC_CTX *_mem_save_info1_0;
15572         TALLOC_CTX *_mem_save_info2_0;
15573         level = ndr_pull_get_switch_value(ndr, r);
15574         if (ndr_flags & NDR_SCALARS) {
15575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15576                 if (_level != level) {
15577                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15578                 }
15579                 switch (level) {
15580                         case 1: {
15581                                 uint32_t _ptr_info1;
15582                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15583                                 if (_ptr_info1) {
15584                                         NDR_PULL_ALLOC(ndr, r->info1);
15585                                 } else {
15586                                         r->info1 = NULL;
15587                                 }
15588                         break; }
15589
15590                         case 2: {
15591                                 uint32_t _ptr_info2;
15592                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15593                                 if (_ptr_info2) {
15594                                         NDR_PULL_ALLOC(ndr, r->info2);
15595                                 } else {
15596                                         r->info2 = NULL;
15597                                 }
15598                         break; }
15599
15600                         default:
15601                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15602                 }
15603         }
15604         if (ndr_flags & NDR_BUFFERS) {
15605                 switch (level) {
15606                         case 1:
15607                                 if (r->info1) {
15608                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15609                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15610                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15611                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15612                                 }
15613                         break;
15614
15615                         case 2:
15616                                 if (r->info2) {
15617                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15618                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15619                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15620                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15621                                 }
15622                         break;
15623
15624                         default:
15625                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15626                 }
15627         }
15628         return NDR_ERR_SUCCESS;
15629 }
15630
15631 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15632 {
15633         int level;
15634         level = ndr_print_get_switch_value(ndr, r);
15635         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15636         switch (level) {
15637                 case 1:
15638                         ndr_print_ptr(ndr, "info1", r->info1);
15639                         ndr->depth++;
15640                         if (r->info1) {
15641                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15642                         }
15643                         ndr->depth--;
15644                 break;
15645
15646                 case 2:
15647                         ndr_print_ptr(ndr, "info2", r->info2);
15648                         ndr->depth++;
15649                         if (r->info2) {
15650                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15651                         }
15652                         ndr->depth--;
15653                 break;
15654
15655                 default:
15656                         ndr_print_bad_level(ndr, name, level);
15657         }
15658 }
15659
15660 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15661 {
15662         if (ndr_flags & NDR_SCALARS) {
15663                 NDR_CHECK(ndr_push_align(ndr, 4));
15664                 {
15665                         uint32_t _flags_save_string = ndr->flags;
15666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15667                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15668                         ndr->flags = _flags_save_string;
15669                 }
15670         }
15671         if (ndr_flags & NDR_BUFFERS) {
15672                 {
15673                         uint32_t _flags_save_string = ndr->flags;
15674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15675                         if (r->port_name) {
15676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15678                         }
15679                         ndr->flags = _flags_save_string;
15680                 }
15681         }
15682         return NDR_ERR_SUCCESS;
15683 }
15684
15685 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15686 {
15687         uint32_t _ptr_port_name;
15688         TALLOC_CTX *_mem_save_port_name_0;
15689         if (ndr_flags & NDR_SCALARS) {
15690                 NDR_CHECK(ndr_pull_align(ndr, 4));
15691                 {
15692                         uint32_t _flags_save_string = ndr->flags;
15693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15695                         if (_ptr_port_name) {
15696                                 NDR_PULL_ALLOC(ndr, r->port_name);
15697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15698                         } else {
15699                                 r->port_name = NULL;
15700                         }
15701                         ndr->flags = _flags_save_string;
15702                 }
15703         }
15704         if (ndr_flags & NDR_BUFFERS) {
15705                 {
15706                         uint32_t _flags_save_string = ndr->flags;
15707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15708                         if (r->port_name) {
15709                                 uint32_t _relative_save_offset;
15710                                 _relative_save_offset = ndr->offset;
15711                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15712                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15713                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15714                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15715                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15716                                 ndr->offset = _relative_save_offset;
15717                         }
15718                         ndr->flags = _flags_save_string;
15719                 }
15720         }
15721         return NDR_ERR_SUCCESS;
15722 }
15723
15724 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15725 {
15726         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15727         ndr->depth++;
15728         ndr_print_ptr(ndr, "port_name", r->port_name);
15729         ndr->depth++;
15730         if (r->port_name) {
15731                 ndr_print_string(ndr, "port_name", r->port_name);
15732         }
15733         ndr->depth--;
15734         ndr->depth--;
15735 }
15736
15737 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15738 {
15739         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15740 }
15741
15742 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15743 {
15744         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15745         return NDR_ERR_SUCCESS;
15746 }
15747
15748 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15749 {
15750         uint32_t v;
15751         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15752         *r = v;
15753         return NDR_ERR_SUCCESS;
15754 }
15755
15756 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15757 {
15758         ndr_print_uint32(ndr, name, r);
15759         ndr->depth++;
15760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15763         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15764         ndr->depth--;
15765 }
15766
15767 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15768 {
15769         if (ndr_flags & NDR_SCALARS) {
15770                 NDR_CHECK(ndr_push_align(ndr, 4));
15771                 {
15772                         uint32_t _flags_save_string = ndr->flags;
15773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15775                         ndr->flags = _flags_save_string;
15776                 }
15777                 {
15778                         uint32_t _flags_save_string = ndr->flags;
15779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15781                         ndr->flags = _flags_save_string;
15782                 }
15783                 {
15784                         uint32_t _flags_save_string = ndr->flags;
15785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15787                         ndr->flags = _flags_save_string;
15788                 }
15789                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15791         }
15792         if (ndr_flags & NDR_BUFFERS) {
15793                 {
15794                         uint32_t _flags_save_string = ndr->flags;
15795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15796                         if (r->port_name) {
15797                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15798                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15799                         }
15800                         ndr->flags = _flags_save_string;
15801                 }
15802                 {
15803                         uint32_t _flags_save_string = ndr->flags;
15804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15805                         if (r->monitor_name) {
15806                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15807                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15808                         }
15809                         ndr->flags = _flags_save_string;
15810                 }
15811                 {
15812                         uint32_t _flags_save_string = ndr->flags;
15813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15814                         if (r->description) {
15815                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15816                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15817                         }
15818                         ndr->flags = _flags_save_string;
15819                 }
15820         }
15821         return NDR_ERR_SUCCESS;
15822 }
15823
15824 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15825 {
15826         uint32_t _ptr_port_name;
15827         TALLOC_CTX *_mem_save_port_name_0;
15828         uint32_t _ptr_monitor_name;
15829         TALLOC_CTX *_mem_save_monitor_name_0;
15830         uint32_t _ptr_description;
15831         TALLOC_CTX *_mem_save_description_0;
15832         if (ndr_flags & NDR_SCALARS) {
15833                 NDR_CHECK(ndr_pull_align(ndr, 4));
15834                 {
15835                         uint32_t _flags_save_string = ndr->flags;
15836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15837                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15838                         if (_ptr_port_name) {
15839                                 NDR_PULL_ALLOC(ndr, r->port_name);
15840                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15841                         } else {
15842                                 r->port_name = NULL;
15843                         }
15844                         ndr->flags = _flags_save_string;
15845                 }
15846                 {
15847                         uint32_t _flags_save_string = ndr->flags;
15848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15849                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15850                         if (_ptr_monitor_name) {
15851                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15852                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15853                         } else {
15854                                 r->monitor_name = NULL;
15855                         }
15856                         ndr->flags = _flags_save_string;
15857                 }
15858                 {
15859                         uint32_t _flags_save_string = ndr->flags;
15860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15862                         if (_ptr_description) {
15863                                 NDR_PULL_ALLOC(ndr, r->description);
15864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15865                         } else {
15866                                 r->description = NULL;
15867                         }
15868                         ndr->flags = _flags_save_string;
15869                 }
15870                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15872         }
15873         if (ndr_flags & NDR_BUFFERS) {
15874                 {
15875                         uint32_t _flags_save_string = ndr->flags;
15876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                         if (r->port_name) {
15878                                 uint32_t _relative_save_offset;
15879                                 _relative_save_offset = ndr->offset;
15880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15881                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15882                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15885                                 ndr->offset = _relative_save_offset;
15886                         }
15887                         ndr->flags = _flags_save_string;
15888                 }
15889                 {
15890                         uint32_t _flags_save_string = ndr->flags;
15891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15892                         if (r->monitor_name) {
15893                                 uint32_t _relative_save_offset;
15894                                 _relative_save_offset = ndr->offset;
15895                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15896                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15897                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15898                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15899                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15900                                 ndr->offset = _relative_save_offset;
15901                         }
15902                         ndr->flags = _flags_save_string;
15903                 }
15904                 {
15905                         uint32_t _flags_save_string = ndr->flags;
15906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15907                         if (r->description) {
15908                                 uint32_t _relative_save_offset;
15909                                 _relative_save_offset = ndr->offset;
15910                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15911                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15912                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15913                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15915                                 ndr->offset = _relative_save_offset;
15916                         }
15917                         ndr->flags = _flags_save_string;
15918                 }
15919         }
15920         return NDR_ERR_SUCCESS;
15921 }
15922
15923 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15924 {
15925         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15926         ndr->depth++;
15927         ndr_print_ptr(ndr, "port_name", r->port_name);
15928         ndr->depth++;
15929         if (r->port_name) {
15930                 ndr_print_string(ndr, "port_name", r->port_name);
15931         }
15932         ndr->depth--;
15933         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15934         ndr->depth++;
15935         if (r->monitor_name) {
15936                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15937         }
15938         ndr->depth--;
15939         ndr_print_ptr(ndr, "description", r->description);
15940         ndr->depth++;
15941         if (r->description) {
15942                 ndr_print_string(ndr, "description", r->description);
15943         }
15944         ndr->depth--;
15945         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15946         ndr_print_uint32(ndr, "reserved", r->reserved);
15947         ndr->depth--;
15948 }
15949
15950 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15951 {
15952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15953 }
15954
15955 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15956 {
15957         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15958         return NDR_ERR_SUCCESS;
15959 }
15960
15961 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15962 {
15963         uint32_t v;
15964         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15965         *r = v;
15966         return NDR_ERR_SUCCESS;
15967 }
15968
15969 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15970 {
15971         const char *val = NULL;
15972
15973         switch (r) {
15974                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15975                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15976                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15977                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15978                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15979                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15980                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15981                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15982                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
15983                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
15984                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
15985                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
15986                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
15987         }
15988         ndr_print_enum(ndr, name, "ENUM", val, r);
15989 }
15990
15991 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
15992 {
15993         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15994         return NDR_ERR_SUCCESS;
15995 }
15996
15997 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
15998 {
15999         uint32_t v;
16000         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16001         *r = v;
16002         return NDR_ERR_SUCCESS;
16003 }
16004
16005 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16006 {
16007         const char *val = NULL;
16008
16009         switch (r) {
16010                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16011                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16012                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16013         }
16014         ndr_print_enum(ndr, name, "ENUM", val, r);
16015 }
16016
16017 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16018 {
16019         if (ndr_flags & NDR_SCALARS) {
16020                 NDR_CHECK(ndr_push_align(ndr, 4));
16021                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16022                 {
16023                         uint32_t _flags_save_string = ndr->flags;
16024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16026                         ndr->flags = _flags_save_string;
16027                 }
16028                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16029         }
16030         if (ndr_flags & NDR_BUFFERS) {
16031                 {
16032                         uint32_t _flags_save_string = ndr->flags;
16033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16034                         if (r->status_string) {
16035                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16036                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16037                         }
16038                         ndr->flags = _flags_save_string;
16039                 }
16040         }
16041         return NDR_ERR_SUCCESS;
16042 }
16043
16044 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16045 {
16046         uint32_t _ptr_status_string;
16047         TALLOC_CTX *_mem_save_status_string_0;
16048         if (ndr_flags & NDR_SCALARS) {
16049                 NDR_CHECK(ndr_pull_align(ndr, 4));
16050                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16051                 {
16052                         uint32_t _flags_save_string = ndr->flags;
16053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16054                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16055                         if (_ptr_status_string) {
16056                                 NDR_PULL_ALLOC(ndr, r->status_string);
16057                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16058                         } else {
16059                                 r->status_string = NULL;
16060                         }
16061                         ndr->flags = _flags_save_string;
16062                 }
16063                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16064         }
16065         if (ndr_flags & NDR_BUFFERS) {
16066                 {
16067                         uint32_t _flags_save_string = ndr->flags;
16068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16069                         if (r->status_string) {
16070                                 uint32_t _relative_save_offset;
16071                                 _relative_save_offset = ndr->offset;
16072                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16073                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16074                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16075                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16076                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16077                                 ndr->offset = _relative_save_offset;
16078                         }
16079                         ndr->flags = _flags_save_string;
16080                 }
16081         }
16082         return NDR_ERR_SUCCESS;
16083 }
16084
16085 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16086 {
16087         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16088         ndr->depth++;
16089         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16090         ndr_print_ptr(ndr, "status_string", r->status_string);
16091         ndr->depth++;
16092         if (r->status_string) {
16093                 ndr_print_string(ndr, "status_string", r->status_string);
16094         }
16095         ndr->depth--;
16096         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16097         ndr->depth--;
16098 }
16099
16100 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16101 {
16102         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16103 }
16104
16105 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16106 {
16107         if (ndr_flags & NDR_SCALARS) {
16108                 NDR_CHECK(ndr_push_align(ndr, 4));
16109                 {
16110                         uint32_t _flags_save_string = ndr->flags;
16111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16112                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16113                         ndr->flags = _flags_save_string;
16114                 }
16115                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16116         }
16117         if (ndr_flags & NDR_BUFFERS) {
16118                 {
16119                         uint32_t _flags_save_string = ndr->flags;
16120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16121                         if (r->port_name) {
16122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16124                         }
16125                         ndr->flags = _flags_save_string;
16126                 }
16127         }
16128         return NDR_ERR_SUCCESS;
16129 }
16130
16131 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16132 {
16133         uint32_t _ptr_port_name;
16134         TALLOC_CTX *_mem_save_port_name_0;
16135         if (ndr_flags & NDR_SCALARS) {
16136                 NDR_CHECK(ndr_pull_align(ndr, 4));
16137                 {
16138                         uint32_t _flags_save_string = ndr->flags;
16139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16140                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16141                         if (_ptr_port_name) {
16142                                 NDR_PULL_ALLOC(ndr, r->port_name);
16143                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16144                         } else {
16145                                 r->port_name = NULL;
16146                         }
16147                         ndr->flags = _flags_save_string;
16148                 }
16149                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16150         }
16151         if (ndr_flags & NDR_BUFFERS) {
16152                 {
16153                         uint32_t _flags_save_string = ndr->flags;
16154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16155                         if (r->port_name) {
16156                                 uint32_t _relative_save_offset;
16157                                 _relative_save_offset = ndr->offset;
16158                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16159                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16160                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16161                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16162                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16163                                 ndr->offset = _relative_save_offset;
16164                         }
16165                         ndr->flags = _flags_save_string;
16166                 }
16167         }
16168         return NDR_ERR_SUCCESS;
16169 }
16170
16171 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16172 {
16173         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16174         ndr->depth++;
16175         ndr_print_ptr(ndr, "port_name", r->port_name);
16176         ndr->depth++;
16177         if (r->port_name) {
16178                 ndr_print_string(ndr, "port_name", r->port_name);
16179         }
16180         ndr->depth--;
16181         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16182         ndr->depth--;
16183 }
16184
16185 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16186 {
16187         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16188 }
16189
16190 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16191 {
16192         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16193         if (ndr_flags & NDR_SCALARS) {
16194                 int level = ndr_push_get_switch_value(ndr, r);
16195                 switch (level) {
16196                         case 1: {
16197                                 NDR_CHECK(ndr_push_align(ndr, 4));
16198                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16199                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16200                         break; }
16201
16202                         case 2: {
16203                                 NDR_CHECK(ndr_push_align(ndr, 4));
16204                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16205                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16206                         break; }
16207
16208                         case 3: {
16209                                 NDR_CHECK(ndr_push_align(ndr, 4));
16210                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16211                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16212                         break; }
16213
16214                         case 0xff: {
16215                                 NDR_CHECK(ndr_push_align(ndr, 4));
16216                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16217                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16218                         break; }
16219
16220                         default: {
16221                         break; }
16222
16223                 }
16224         }
16225         if (ndr_flags & NDR_BUFFERS) {
16226                 int level = ndr_push_get_switch_value(ndr, r);
16227                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16228                 switch (level) {
16229                         case 1:
16230                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16231                         break;
16232
16233                         case 2:
16234                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16235                         break;
16236
16237                         case 3:
16238                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16239                         break;
16240
16241                         case 0xff:
16242                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16243                         break;
16244
16245                         default:
16246                         break;
16247
16248                 }
16249         }
16250         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16251         return NDR_ERR_SUCCESS;
16252 }
16253
16254 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16255 {
16256         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16257         int level;
16258         level = ndr_pull_get_switch_value(ndr, r);
16259         if (ndr_flags & NDR_SCALARS) {
16260                 switch (level) {
16261                         case 1: {
16262                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16263                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16264                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16265                         break; }
16266
16267                         case 2: {
16268                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16269                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16270                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16271                         break; }
16272
16273                         case 3: {
16274                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16275                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16276                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16277                         break; }
16278
16279                         case 0xff: {
16280                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16281                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16282                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16283                         break; }
16284
16285                         default: {
16286                         break; }
16287
16288                 }
16289         }
16290         if (ndr_flags & NDR_BUFFERS) {
16291                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16292                 switch (level) {
16293                         case 1:
16294                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16295                         break;
16296
16297                         case 2:
16298                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16299                         break;
16300
16301                         case 3:
16302                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16303                         break;
16304
16305                         case 0xff:
16306                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16307                         break;
16308
16309                         default:
16310                         break;
16311
16312                 }
16313         }
16314         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16315         return NDR_ERR_SUCCESS;
16316 }
16317
16318 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16319 {
16320         int level;
16321         level = ndr_print_get_switch_value(ndr, r);
16322         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16323         switch (level) {
16324                 case 1:
16325                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16326                 break;
16327
16328                 case 2:
16329                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16330                 break;
16331
16332                 case 3:
16333                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16334                 break;
16335
16336                 case 0xff:
16337                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16338                 break;
16339
16340                 default:
16341                 break;
16342
16343         }
16344 }
16345
16346 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16347 {
16348         if (ndr_flags & NDR_SCALARS) {
16349                 NDR_CHECK(ndr_push_align(ndr, 4));
16350                 {
16351                         uint32_t _flags_save_string = ndr->flags;
16352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16354                         ndr->flags = _flags_save_string;
16355                 }
16356         }
16357         if (ndr_flags & NDR_BUFFERS) {
16358                 {
16359                         uint32_t _flags_save_string = ndr->flags;
16360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16361                         if (r->monitor_name) {
16362                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16364                         }
16365                         ndr->flags = _flags_save_string;
16366                 }
16367         }
16368         return NDR_ERR_SUCCESS;
16369 }
16370
16371 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16372 {
16373         uint32_t _ptr_monitor_name;
16374         TALLOC_CTX *_mem_save_monitor_name_0;
16375         if (ndr_flags & NDR_SCALARS) {
16376                 NDR_CHECK(ndr_pull_align(ndr, 4));
16377                 {
16378                         uint32_t _flags_save_string = ndr->flags;
16379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16380                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16381                         if (_ptr_monitor_name) {
16382                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16383                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16384                         } else {
16385                                 r->monitor_name = NULL;
16386                         }
16387                         ndr->flags = _flags_save_string;
16388                 }
16389         }
16390         if (ndr_flags & NDR_BUFFERS) {
16391                 {
16392                         uint32_t _flags_save_string = ndr->flags;
16393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16394                         if (r->monitor_name) {
16395                                 uint32_t _relative_save_offset;
16396                                 _relative_save_offset = ndr->offset;
16397                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16398                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16399                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16400                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16401                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16402                                 ndr->offset = _relative_save_offset;
16403                         }
16404                         ndr->flags = _flags_save_string;
16405                 }
16406         }
16407         return NDR_ERR_SUCCESS;
16408 }
16409
16410 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16411 {
16412         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16413         ndr->depth++;
16414         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16415         ndr->depth++;
16416         if (r->monitor_name) {
16417                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16418         }
16419         ndr->depth--;
16420         ndr->depth--;
16421 }
16422
16423 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16424 {
16425         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16426 }
16427
16428 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16429 {
16430         if (ndr_flags & NDR_SCALARS) {
16431                 NDR_CHECK(ndr_push_align(ndr, 4));
16432                 {
16433                         uint32_t _flags_save_string = ndr->flags;
16434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16436                         ndr->flags = _flags_save_string;
16437                 }
16438                 {
16439                         uint32_t _flags_save_string = ndr->flags;
16440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16441                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16442                         ndr->flags = _flags_save_string;
16443                 }
16444                 {
16445                         uint32_t _flags_save_string = ndr->flags;
16446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16447                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16448                         ndr->flags = _flags_save_string;
16449                 }
16450         }
16451         if (ndr_flags & NDR_BUFFERS) {
16452                 {
16453                         uint32_t _flags_save_string = ndr->flags;
16454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16455                         if (r->monitor_name) {
16456                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16457                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16458                         }
16459                         ndr->flags = _flags_save_string;
16460                 }
16461                 {
16462                         uint32_t _flags_save_string = ndr->flags;
16463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16464                         if (r->environment) {
16465                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16466                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16467                         }
16468                         ndr->flags = _flags_save_string;
16469                 }
16470                 {
16471                         uint32_t _flags_save_string = ndr->flags;
16472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16473                         if (r->dll_name) {
16474                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16475                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16476                         }
16477                         ndr->flags = _flags_save_string;
16478                 }
16479         }
16480         return NDR_ERR_SUCCESS;
16481 }
16482
16483 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16484 {
16485         uint32_t _ptr_monitor_name;
16486         TALLOC_CTX *_mem_save_monitor_name_0;
16487         uint32_t _ptr_environment;
16488         TALLOC_CTX *_mem_save_environment_0;
16489         uint32_t _ptr_dll_name;
16490         TALLOC_CTX *_mem_save_dll_name_0;
16491         if (ndr_flags & NDR_SCALARS) {
16492                 NDR_CHECK(ndr_pull_align(ndr, 4));
16493                 {
16494                         uint32_t _flags_save_string = ndr->flags;
16495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16496                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16497                         if (_ptr_monitor_name) {
16498                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16499                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16500                         } else {
16501                                 r->monitor_name = NULL;
16502                         }
16503                         ndr->flags = _flags_save_string;
16504                 }
16505                 {
16506                         uint32_t _flags_save_string = ndr->flags;
16507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16508                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16509                         if (_ptr_environment) {
16510                                 NDR_PULL_ALLOC(ndr, r->environment);
16511                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16512                         } else {
16513                                 r->environment = NULL;
16514                         }
16515                         ndr->flags = _flags_save_string;
16516                 }
16517                 {
16518                         uint32_t _flags_save_string = ndr->flags;
16519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16520                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16521                         if (_ptr_dll_name) {
16522                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16523                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16524                         } else {
16525                                 r->dll_name = NULL;
16526                         }
16527                         ndr->flags = _flags_save_string;
16528                 }
16529         }
16530         if (ndr_flags & NDR_BUFFERS) {
16531                 {
16532                         uint32_t _flags_save_string = ndr->flags;
16533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16534                         if (r->monitor_name) {
16535                                 uint32_t _relative_save_offset;
16536                                 _relative_save_offset = ndr->offset;
16537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16538                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16539                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16542                                 ndr->offset = _relative_save_offset;
16543                         }
16544                         ndr->flags = _flags_save_string;
16545                 }
16546                 {
16547                         uint32_t _flags_save_string = ndr->flags;
16548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16549                         if (r->environment) {
16550                                 uint32_t _relative_save_offset;
16551                                 _relative_save_offset = ndr->offset;
16552                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16553                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16554                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16555                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16556                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16557                                 ndr->offset = _relative_save_offset;
16558                         }
16559                         ndr->flags = _flags_save_string;
16560                 }
16561                 {
16562                         uint32_t _flags_save_string = ndr->flags;
16563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16564                         if (r->dll_name) {
16565                                 uint32_t _relative_save_offset;
16566                                 _relative_save_offset = ndr->offset;
16567                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16568                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16569                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16570                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16571                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16572                                 ndr->offset = _relative_save_offset;
16573                         }
16574                         ndr->flags = _flags_save_string;
16575                 }
16576         }
16577         return NDR_ERR_SUCCESS;
16578 }
16579
16580 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16581 {
16582         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16583         ndr->depth++;
16584         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16585         ndr->depth++;
16586         if (r->monitor_name) {
16587                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16588         }
16589         ndr->depth--;
16590         ndr_print_ptr(ndr, "environment", r->environment);
16591         ndr->depth++;
16592         if (r->environment) {
16593                 ndr_print_string(ndr, "environment", r->environment);
16594         }
16595         ndr->depth--;
16596         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16597         ndr->depth++;
16598         if (r->dll_name) {
16599                 ndr_print_string(ndr, "dll_name", r->dll_name);
16600         }
16601         ndr->depth--;
16602         ndr->depth--;
16603 }
16604
16605 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16606 {
16607         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16608 }
16609
16610 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16611 {
16612         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16613         if (ndr_flags & NDR_SCALARS) {
16614                 int level = ndr_push_get_switch_value(ndr, r);
16615                 switch (level) {
16616                         case 1: {
16617                                 NDR_CHECK(ndr_push_align(ndr, 4));
16618                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16619                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16620                         break; }
16621
16622                         case 2: {
16623                                 NDR_CHECK(ndr_push_align(ndr, 4));
16624                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16625                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16626                         break; }
16627
16628                         default: {
16629                         break; }
16630
16631                 }
16632         }
16633         if (ndr_flags & NDR_BUFFERS) {
16634                 int level = ndr_push_get_switch_value(ndr, r);
16635                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16636                 switch (level) {
16637                         case 1:
16638                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16639                         break;
16640
16641                         case 2:
16642                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16643                         break;
16644
16645                         default:
16646                         break;
16647
16648                 }
16649         }
16650         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16651         return NDR_ERR_SUCCESS;
16652 }
16653
16654 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16655 {
16656         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16657         int level;
16658         level = ndr_pull_get_switch_value(ndr, r);
16659         if (ndr_flags & NDR_SCALARS) {
16660                 switch (level) {
16661                         case 1: {
16662                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16663                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16664                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16665                         break; }
16666
16667                         case 2: {
16668                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16669                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16670                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16671                         break; }
16672
16673                         default: {
16674                         break; }
16675
16676                 }
16677         }
16678         if (ndr_flags & NDR_BUFFERS) {
16679                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16680                 switch (level) {
16681                         case 1:
16682                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16683                         break;
16684
16685                         case 2:
16686                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16687                         break;
16688
16689                         default:
16690                         break;
16691
16692                 }
16693         }
16694         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16695         return NDR_ERR_SUCCESS;
16696 }
16697
16698 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16699 {
16700         int level;
16701         level = ndr_print_get_switch_value(ndr, r);
16702         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16703         switch (level) {
16704                 case 1:
16705                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16706                 break;
16707
16708                 case 2:
16709                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16710                 break;
16711
16712                 default:
16713                 break;
16714
16715         }
16716 }
16717
16718 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16719 {
16720         if (ndr_flags & NDR_SCALARS) {
16721                 NDR_CHECK(ndr_push_align(ndr, 4));
16722                 {
16723                         uint32_t _flags_save_string = ndr->flags;
16724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16725                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16726                         ndr->flags = _flags_save_string;
16727                 }
16728         }
16729         if (ndr_flags & NDR_BUFFERS) {
16730                 {
16731                         uint32_t _flags_save_string = ndr->flags;
16732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16733                         if (r->name_array) {
16734                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16735                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16736                         }
16737                         ndr->flags = _flags_save_string;
16738                 }
16739         }
16740         return NDR_ERR_SUCCESS;
16741 }
16742
16743 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16744 {
16745         uint32_t _ptr_name_array;
16746         TALLOC_CTX *_mem_save_name_array_0;
16747         if (ndr_flags & NDR_SCALARS) {
16748                 NDR_CHECK(ndr_pull_align(ndr, 4));
16749                 {
16750                         uint32_t _flags_save_string = ndr->flags;
16751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16753                         if (_ptr_name_array) {
16754                                 NDR_PULL_ALLOC(ndr, r->name_array);
16755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16756                         } else {
16757                                 r->name_array = NULL;
16758                         }
16759                         ndr->flags = _flags_save_string;
16760                 }
16761         }
16762         if (ndr_flags & NDR_BUFFERS) {
16763                 {
16764                         uint32_t _flags_save_string = ndr->flags;
16765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16766                         if (r->name_array) {
16767                                 uint32_t _relative_save_offset;
16768                                 _relative_save_offset = ndr->offset;
16769                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16770                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16771                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16772                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16773                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16774                                 ndr->offset = _relative_save_offset;
16775                         }
16776                         ndr->flags = _flags_save_string;
16777                 }
16778         }
16779         return NDR_ERR_SUCCESS;
16780 }
16781
16782 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16783 {
16784         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16785         ndr->depth++;
16786         ndr_print_ptr(ndr, "name_array", r->name_array);
16787         ndr->depth++;
16788         if (r->name_array) {
16789                 ndr_print_string(ndr, "name_array", r->name_array);
16790         }
16791         ndr->depth--;
16792         ndr->depth--;
16793 }
16794
16795 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16796 {
16797         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16798 }
16799
16800 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16801 {
16802         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16803         if (ndr_flags & NDR_SCALARS) {
16804                 int level = ndr_push_get_switch_value(ndr, r);
16805                 switch (level) {
16806                         case 1: {
16807                                 NDR_CHECK(ndr_push_align(ndr, 4));
16808                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16809                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16810                         break; }
16811
16812                         default: {
16813                         break; }
16814
16815                 }
16816         }
16817         if (ndr_flags & NDR_BUFFERS) {
16818                 int level = ndr_push_get_switch_value(ndr, r);
16819                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16820                 switch (level) {
16821                         case 1:
16822                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16823                         break;
16824
16825                         default:
16826                         break;
16827
16828                 }
16829         }
16830         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16831         return NDR_ERR_SUCCESS;
16832 }
16833
16834 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16835 {
16836         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16837         int level;
16838         level = ndr_pull_get_switch_value(ndr, r);
16839         if (ndr_flags & NDR_SCALARS) {
16840                 switch (level) {
16841                         case 1: {
16842                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16843                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16844                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16845                         break; }
16846
16847                         default: {
16848                         break; }
16849
16850                 }
16851         }
16852         if (ndr_flags & NDR_BUFFERS) {
16853                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16854                 switch (level) {
16855                         case 1:
16856                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16857                         break;
16858
16859                         default:
16860                         break;
16861
16862                 }
16863         }
16864         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16865         return NDR_ERR_SUCCESS;
16866 }
16867
16868 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16869 {
16870         int level;
16871         level = ndr_print_get_switch_value(ndr, r);
16872         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16873         switch (level) {
16874                 case 1:
16875                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16876                 break;
16877
16878                 default:
16879                 break;
16880
16881         }
16882 }
16883
16884 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16885 {
16886         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16887         return NDR_ERR_SUCCESS;
16888 }
16889
16890 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16891 {
16892         uint32_t v;
16893         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16894         *r = v;
16895         return NDR_ERR_SUCCESS;
16896 }
16897
16898 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16899 {
16900         ndr_print_uint32(ndr, name, r);
16901         ndr->depth++;
16902         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16903         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16904         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16905         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16906         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16907         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16908         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16909         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16910         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16911         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16912         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16915         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16918         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16919         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16920         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16921         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16922         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16923         ndr->depth--;
16924 }
16925
16926 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16927 {
16928         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16929         return NDR_ERR_SUCCESS;
16930 }
16931
16932 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16933 {
16934         uint16_t v;
16935         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16936         *r = v;
16937         return NDR_ERR_SUCCESS;
16938 }
16939
16940 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16941 {
16942         const char *val = NULL;
16943
16944         switch (r) {
16945                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16946                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16947                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16948                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16949                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16950                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16951                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16952                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16953                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16954                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16955                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16956                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16957                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16958                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16959                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16960                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16961                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16962                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16963                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16964                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16965                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16966                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16967                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16968                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16969                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16970                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16971         }
16972         ndr_print_enum(ndr, name, "ENUM", val, r);
16973 }
16974
16975 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16976 {
16977         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16978         return NDR_ERR_SUCCESS;
16979 }
16980
16981 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16982 {
16983         uint16_t v;
16984         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16985         *r = v;
16986         return NDR_ERR_SUCCESS;
16987 }
16988
16989 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
16990 {
16991         const char *val = NULL;
16992
16993         switch (r) {
16994                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
16995                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
16996         }
16997         ndr_print_enum(ndr, name, "ENUM", val, r);
16998 }
16999
17000 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17001 {
17002         uint32_t cntr_fields_1;
17003         if (ndr_flags & NDR_SCALARS) {
17004                 NDR_CHECK(ndr_push_align(ndr, 4));
17005                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17006                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17011         }
17012         if (ndr_flags & NDR_BUFFERS) {
17013                 if (r->fields) {
17014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17015                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17016                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17017                         }
17018                 }
17019         }
17020         return NDR_ERR_SUCCESS;
17021 }
17022
17023 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17024 {
17025         uint32_t _ptr_fields;
17026         uint32_t cntr_fields_1;
17027         TALLOC_CTX *_mem_save_fields_0;
17028         TALLOC_CTX *_mem_save_fields_1;
17029         if (ndr_flags & NDR_SCALARS) {
17030                 NDR_CHECK(ndr_pull_align(ndr, 4));
17031                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17032                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17037                 if (_ptr_fields) {
17038                         NDR_PULL_ALLOC(ndr, r->fields);
17039                 } else {
17040                         r->fields = NULL;
17041                 }
17042         }
17043         if (ndr_flags & NDR_BUFFERS) {
17044                 if (r->fields) {
17045                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17046                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17048                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17049                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17050                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17051                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17052                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17053                         }
17054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17056                 }
17057                 if (r->fields) {
17058                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17059                 }
17060         }
17061         return NDR_ERR_SUCCESS;
17062 }
17063
17064 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17065 {
17066         uint32_t cntr_fields_1;
17067         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17068         ndr->depth++;
17069         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17070         ndr_print_uint16(ndr, "u1", r->u1);
17071         ndr_print_uint32(ndr, "u2", r->u2);
17072         ndr_print_uint32(ndr, "u3", r->u3);
17073         ndr_print_uint32(ndr, "count", r->count);
17074         ndr_print_ptr(ndr, "fields", r->fields);
17075         ndr->depth++;
17076         if (r->fields) {
17077                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17078                 ndr->depth++;
17079                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17080                         char *idx_1=NULL;
17081                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17082                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17083                                 free(idx_1);
17084                         }
17085                 }
17086                 ndr->depth--;
17087         }
17088         ndr->depth--;
17089         ndr->depth--;
17090 }
17091
17092 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17093 {
17094         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17095         return NDR_ERR_SUCCESS;
17096 }
17097
17098 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17099 {
17100         uint32_t v;
17101         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17102         *r = v;
17103         return NDR_ERR_SUCCESS;
17104 }
17105
17106 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17107 {
17108         ndr_print_uint32(ndr, name, r);
17109         ndr->depth++;
17110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17111         ndr->depth--;
17112 }
17113
17114 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17115 {
17116         uint32_t cntr_types_1;
17117         if (ndr_flags & NDR_SCALARS) {
17118                 NDR_CHECK(ndr_push_align(ndr, 4));
17119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17120                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17123         }
17124         if (ndr_flags & NDR_BUFFERS) {
17125                 if (r->types) {
17126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17127                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17128                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17129                         }
17130                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17131                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17132                         }
17133                 }
17134         }
17135         return NDR_ERR_SUCCESS;
17136 }
17137
17138 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17139 {
17140         uint32_t _ptr_types;
17141         uint32_t cntr_types_1;
17142         TALLOC_CTX *_mem_save_types_0;
17143         TALLOC_CTX *_mem_save_types_1;
17144         if (ndr_flags & NDR_SCALARS) {
17145                 NDR_CHECK(ndr_pull_align(ndr, 4));
17146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17147                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17150                 if (_ptr_types) {
17151                         NDR_PULL_ALLOC(ndr, r->types);
17152                 } else {
17153                         r->types = NULL;
17154                 }
17155         }
17156         if (ndr_flags & NDR_BUFFERS) {
17157                 if (r->types) {
17158                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17159                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17161                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17162                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17163                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17164                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17165                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17166                         }
17167                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17168                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17169                         }
17170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17172                 }
17173                 if (r->types) {
17174                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17175                 }
17176         }
17177         return NDR_ERR_SUCCESS;
17178 }
17179
17180 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17181 {
17182         uint32_t cntr_types_1;
17183         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17184         ndr->depth++;
17185         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17186         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17187         ndr_print_uint32(ndr, "count", r->count);
17188         ndr_print_ptr(ndr, "types", r->types);
17189         ndr->depth++;
17190         if (r->types) {
17191                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17192                 ndr->depth++;
17193                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17194                         char *idx_1=NULL;
17195                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17196                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17197                                 free(idx_1);
17198                         }
17199                 }
17200                 ndr->depth--;
17201         }
17202         ndr->depth--;
17203         ndr->depth--;
17204 }
17205
17206 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17207 {
17208         if (ndr_flags & NDR_SCALARS) {
17209                 NDR_CHECK(ndr_push_align(ndr, 4));
17210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17212         }
17213         if (ndr_flags & NDR_BUFFERS) {
17214                 if (r->string) {
17215                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17216                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17217                 }
17218         }
17219         return NDR_ERR_SUCCESS;
17220 }
17221
17222 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17223 {
17224         uint32_t _ptr_string;
17225         TALLOC_CTX *_mem_save_string_0;
17226         if (ndr_flags & NDR_SCALARS) {
17227                 NDR_CHECK(ndr_pull_align(ndr, 4));
17228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17230                 if (_ptr_string) {
17231                         NDR_PULL_ALLOC(ndr, r->string);
17232                 } else {
17233                         r->string = NULL;
17234                 }
17235         }
17236         if (ndr_flags & NDR_BUFFERS) {
17237                 if (r->string) {
17238                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17239                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17240                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17241                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17243                 }
17244                 if (r->string) {
17245                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17246                 }
17247         }
17248         return NDR_ERR_SUCCESS;
17249 }
17250
17251 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17252 {
17253         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17254         ndr->depth++;
17255         ndr_print_uint32(ndr, "size", r->size);
17256         ndr_print_ptr(ndr, "string", r->string);
17257         ndr->depth++;
17258         if (r->string) {
17259                 ndr_print_string(ndr, "string", r->string);
17260         }
17261         ndr->depth--;
17262         ndr->depth--;
17263 }
17264
17265 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17266 {
17267         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17268         return NDR_ERR_SUCCESS;
17269 }
17270
17271 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17272 {
17273         uint32_t v;
17274         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17275         *r = v;
17276         return NDR_ERR_SUCCESS;
17277 }
17278
17279 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17280 {
17281         const char *val = NULL;
17282
17283         switch (r) {
17284                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17285                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17286                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17287                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17288                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17289         }
17290         ndr_print_enum(ndr, name, "ENUM", val, r);
17291 }
17292
17293 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17294 {
17295         if (ndr_flags & NDR_SCALARS) {
17296                 int level = ndr_push_get_switch_value(ndr, r);
17297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17298                 switch (level) {
17299                         case 1: {
17300                                 uint32_t cntr_integer_0;
17301                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17302                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17303                                 }
17304                         break; }
17305
17306                         case 2: {
17307                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17308                         break; }
17309
17310                         case 3: {
17311                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17312                         break; }
17313
17314                         case 4: {
17315                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17316                         break; }
17317
17318                         case 5: {
17319                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17320                         break; }
17321
17322                         default:
17323                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17324                 }
17325         }
17326         if (ndr_flags & NDR_BUFFERS) {
17327                 int level = ndr_push_get_switch_value(ndr, r);
17328                 switch (level) {
17329                         case 1:
17330                         break;
17331
17332                         case 2:
17333                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17334                         break;
17335
17336                         case 3:
17337                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17338                         break;
17339
17340                         case 4:
17341                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17342                         break;
17343
17344                         case 5:
17345                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17346                         break;
17347
17348                         default:
17349                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17350                 }
17351         }
17352         return NDR_ERR_SUCCESS;
17353 }
17354
17355 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17356 {
17357         int level;
17358         uint32_t _level;
17359         level = ndr_pull_get_switch_value(ndr, r);
17360         if (ndr_flags & NDR_SCALARS) {
17361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17362                 if (_level != level) {
17363                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17364                 }
17365                 switch (level) {
17366                         case 1: {
17367                                 uint32_t cntr_integer_0;
17368                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17369                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17370                                 }
17371                         break; }
17372
17373                         case 2: {
17374                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17375                         break; }
17376
17377                         case 3: {
17378                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17379                         break; }
17380
17381                         case 4: {
17382                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17383                         break; }
17384
17385                         case 5: {
17386                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17387                         break; }
17388
17389                         default:
17390                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17391                 }
17392         }
17393         if (ndr_flags & NDR_BUFFERS) {
17394                 switch (level) {
17395                         case 1:
17396                         break;
17397
17398                         case 2:
17399                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17400                         break;
17401
17402                         case 3:
17403                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17404                         break;
17405
17406                         case 4:
17407                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17408                         break;
17409
17410                         case 5:
17411                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17412                         break;
17413
17414                         default:
17415                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17416                 }
17417         }
17418         return NDR_ERR_SUCCESS;
17419 }
17420
17421 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17422 {
17423         int level;
17424         uint32_t cntr_integer_0;
17425         level = ndr_print_get_switch_value(ndr, r);
17426         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17427         switch (level) {
17428                 case 1:
17429                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17430                         ndr->depth++;
17431                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17432                                 char *idx_0=NULL;
17433                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17434                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17435                                         free(idx_0);
17436                                 }
17437                         }
17438                         ndr->depth--;
17439                 break;
17440
17441                 case 2:
17442                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17443                 break;
17444
17445                 case 3:
17446                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17447                 break;
17448
17449                 case 4:
17450                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17451                 break;
17452
17453                 case 5:
17454                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17455                 break;
17456
17457                 default:
17458                         ndr_print_bad_level(ndr, name, level);
17459         }
17460 }
17461
17462 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17463 {
17464         if (ndr_flags & NDR_SCALARS) {
17465                 NDR_CHECK(ndr_push_align(ndr, 4));
17466                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17467                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17468                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17470                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17471                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17472         }
17473         if (ndr_flags & NDR_BUFFERS) {
17474                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17475         }
17476         return NDR_ERR_SUCCESS;
17477 }
17478
17479 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17480 {
17481         if (ndr_flags & NDR_SCALARS) {
17482                 NDR_CHECK(ndr_pull_align(ndr, 4));
17483                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17484                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17485                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17487                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17488                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17489         }
17490         if (ndr_flags & NDR_BUFFERS) {
17491                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17492         }
17493         return NDR_ERR_SUCCESS;
17494 }
17495
17496 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17497 {
17498         ndr_print_struct(ndr, name, "spoolss_Notify");
17499         ndr->depth++;
17500         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17501         ndr_print_spoolss_Field(ndr, "field", r->field);
17502         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17503         ndr_print_uint32(ndr, "job_id", r->job_id);
17504         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17505         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17506         ndr->depth--;
17507 }
17508
17509 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17510 {
17511         uint32_t cntr_notifies_0;
17512         if (ndr_flags & NDR_SCALARS) {
17513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17514                 NDR_CHECK(ndr_push_align(ndr, 4));
17515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17518                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17519                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17520                 }
17521         }
17522         if (ndr_flags & NDR_BUFFERS) {
17523                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17524                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17525                 }
17526         }
17527         return NDR_ERR_SUCCESS;
17528 }
17529
17530 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17531 {
17532         uint32_t cntr_notifies_0;
17533         TALLOC_CTX *_mem_save_notifies_0;
17534         if (ndr_flags & NDR_SCALARS) {
17535                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17536                 NDR_CHECK(ndr_pull_align(ndr, 4));
17537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17540                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17541                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17542                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17543                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17544                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17545                 }
17546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17547                 if (r->notifies) {
17548                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17549                 }
17550         }
17551         if (ndr_flags & NDR_BUFFERS) {
17552                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17553                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17554                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17555                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17556                 }
17557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17558         }
17559         return NDR_ERR_SUCCESS;
17560 }
17561
17562 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17563 {
17564         uint32_t cntr_notifies_0;
17565         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17566         ndr->depth++;
17567         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17568         ndr_print_uint32(ndr, "flags", r->flags);
17569         ndr_print_uint32(ndr, "count", r->count);
17570         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17571         ndr->depth++;
17572         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17573                 char *idx_0=NULL;
17574                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17575                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17576                         free(idx_0);
17577                 }
17578         }
17579         ndr->depth--;
17580         ndr->depth--;
17581 }
17582
17583 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17584 {
17585         if (ndr_flags & NDR_SCALARS) {
17586                 int level = ndr_push_get_switch_value(ndr, r);
17587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17588                 switch (level) {
17589                         case 0: {
17590                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17591                         break; }
17592
17593                         default:
17594                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17595                 }
17596         }
17597         if (ndr_flags & NDR_BUFFERS) {
17598                 int level = ndr_push_get_switch_value(ndr, r);
17599                 switch (level) {
17600                         case 0:
17601                                 if (r->info0) {
17602                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17603                                 }
17604                         break;
17605
17606                         default:
17607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17608                 }
17609         }
17610         return NDR_ERR_SUCCESS;
17611 }
17612
17613 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17614 {
17615         int level;
17616         uint32_t _level;
17617         TALLOC_CTX *_mem_save_info0_0;
17618         level = ndr_pull_get_switch_value(ndr, r);
17619         if (ndr_flags & NDR_SCALARS) {
17620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17621                 if (_level != level) {
17622                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17623                 }
17624                 switch (level) {
17625                         case 0: {
17626                                 uint32_t _ptr_info0;
17627                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17628                                 if (_ptr_info0) {
17629                                         NDR_PULL_ALLOC(ndr, r->info0);
17630                                 } else {
17631                                         r->info0 = NULL;
17632                                 }
17633                         break; }
17634
17635                         default:
17636                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17637                 }
17638         }
17639         if (ndr_flags & NDR_BUFFERS) {
17640                 switch (level) {
17641                         case 0:
17642                                 if (r->info0) {
17643                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17644                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17645                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17646                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17647                                 }
17648                         break;
17649
17650                         default:
17651                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17652                 }
17653         }
17654         return NDR_ERR_SUCCESS;
17655 }
17656
17657 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17658 {
17659         int level;
17660         level = ndr_print_get_switch_value(ndr, r);
17661         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17662         switch (level) {
17663                 case 0:
17664                         ndr_print_ptr(ndr, "info0", r->info0);
17665                         ndr->depth++;
17666                         if (r->info0) {
17667                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17668                         }
17669                         ndr->depth--;
17670                 break;
17671
17672                 default:
17673                         ndr_print_bad_level(ndr, name, level);
17674         }
17675 }
17676
17677 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17678 {
17679         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17680         return NDR_ERR_SUCCESS;
17681 }
17682
17683 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17684 {
17685         uint32_t v;
17686         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17687         *r = v;
17688         return NDR_ERR_SUCCESS;
17689 }
17690
17691 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17692 {
17693         ndr_print_uint32(ndr, name, r);
17694         ndr->depth++;
17695         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17696         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17697         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17698         ndr->depth--;
17699 }
17700
17701 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17702 {
17703         if (ndr_flags & NDR_SCALARS) {
17704                 NDR_CHECK(ndr_push_align(ndr, 4));
17705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17709                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17710                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17711                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17712         }
17713         if (ndr_flags & NDR_BUFFERS) {
17714                 if (r->client) {
17715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17719                 }
17720                 if (r->user) {
17721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17725                 }
17726         }
17727         return NDR_ERR_SUCCESS;
17728 }
17729
17730 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17731 {
17732         uint32_t _ptr_client;
17733         TALLOC_CTX *_mem_save_client_0;
17734         uint32_t _ptr_user;
17735         TALLOC_CTX *_mem_save_user_0;
17736         if (ndr_flags & NDR_SCALARS) {
17737                 NDR_CHECK(ndr_pull_align(ndr, 4));
17738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17740                 if (_ptr_client) {
17741                         NDR_PULL_ALLOC(ndr, r->client);
17742                 } else {
17743                         r->client = NULL;
17744                 }
17745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17746                 if (_ptr_user) {
17747                         NDR_PULL_ALLOC(ndr, r->user);
17748                 } else {
17749                         r->user = NULL;
17750                 }
17751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17752                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17753                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17754                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17755         }
17756         if (ndr_flags & NDR_BUFFERS) {
17757                 if (r->client) {
17758                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17759                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17761                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17762                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17763                                 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));
17764                         }
17765                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17766                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17767                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17768                 }
17769                 if (r->user) {
17770                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17771                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17774                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17775                                 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));
17776                         }
17777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17780                 }
17781         }
17782         return NDR_ERR_SUCCESS;
17783 }
17784
17785 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17786 {
17787         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17788         ndr->depth++;
17789         ndr_print_uint32(ndr, "size", r->size);
17790         ndr_print_ptr(ndr, "client", r->client);
17791         ndr->depth++;
17792         if (r->client) {
17793                 ndr_print_string(ndr, "client", r->client);
17794         }
17795         ndr->depth--;
17796         ndr_print_ptr(ndr, "user", r->user);
17797         ndr->depth++;
17798         if (r->user) {
17799                 ndr_print_string(ndr, "user", r->user);
17800         }
17801         ndr->depth--;
17802         ndr_print_uint32(ndr, "build", r->build);
17803         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17804         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17805         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17806         ndr->depth--;
17807 }
17808
17809 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17810 {
17811         if (ndr_flags & NDR_SCALARS) {
17812                 NDR_CHECK(ndr_push_align(ndr, 4));
17813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17814         }
17815         if (ndr_flags & NDR_BUFFERS) {
17816         }
17817         return NDR_ERR_SUCCESS;
17818 }
17819
17820 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17821 {
17822         if (ndr_flags & NDR_SCALARS) {
17823                 NDR_CHECK(ndr_pull_align(ndr, 4));
17824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17825         }
17826         if (ndr_flags & NDR_BUFFERS) {
17827         }
17828         return NDR_ERR_SUCCESS;
17829 }
17830
17831 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17832 {
17833         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17834         ndr->depth++;
17835         ndr_print_uint32(ndr, "not_used", r->not_used);
17836         ndr->depth--;
17837 }
17838
17839 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17840 {
17841         if (ndr_flags & NDR_SCALARS) {
17842                 NDR_CHECK(ndr_push_align(ndr, 4));
17843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17849                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17850                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17851                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17852                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17853         }
17854         if (ndr_flags & NDR_BUFFERS) {
17855                 if (r->client) {
17856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17859                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17860                 }
17861                 if (r->user) {
17862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17866                 }
17867         }
17868         return NDR_ERR_SUCCESS;
17869 }
17870
17871 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17872 {
17873         uint32_t _ptr_client;
17874         TALLOC_CTX *_mem_save_client_0;
17875         uint32_t _ptr_user;
17876         TALLOC_CTX *_mem_save_user_0;
17877         if (ndr_flags & NDR_SCALARS) {
17878                 NDR_CHECK(ndr_pull_align(ndr, 4));
17879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17883                 if (_ptr_client) {
17884                         NDR_PULL_ALLOC(ndr, r->client);
17885                 } else {
17886                         r->client = NULL;
17887                 }
17888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17889                 if (_ptr_user) {
17890                         NDR_PULL_ALLOC(ndr, r->user);
17891                 } else {
17892                         r->user = NULL;
17893                 }
17894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17895                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17896                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17897                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17898                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17899         }
17900         if (ndr_flags & NDR_BUFFERS) {
17901                 if (r->client) {
17902                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17903                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17904                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17905                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17906                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17907                                 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));
17908                         }
17909                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17910                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17912                 }
17913                 if (r->user) {
17914                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17915                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17916                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17917                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17918                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17919                                 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));
17920                         }
17921                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17922                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17924                 }
17925         }
17926         return NDR_ERR_SUCCESS;
17927 }
17928
17929 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17930 {
17931         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17932         ndr->depth++;
17933         ndr_print_uint32(ndr, "size", r->size);
17934         ndr_print_uint32(ndr, "flags", r->flags);
17935         ndr_print_uint32(ndr, "size2", r->size2);
17936         ndr_print_ptr(ndr, "client", r->client);
17937         ndr->depth++;
17938         if (r->client) {
17939                 ndr_print_string(ndr, "client", r->client);
17940         }
17941         ndr->depth--;
17942         ndr_print_ptr(ndr, "user", r->user);
17943         ndr->depth++;
17944         if (r->user) {
17945                 ndr_print_string(ndr, "user", r->user);
17946         }
17947         ndr->depth--;
17948         ndr_print_uint32(ndr, "build", r->build);
17949         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17950         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17951         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17952         ndr_print_udlong(ndr, "reserved", r->reserved);
17953         ndr->depth--;
17954 }
17955
17956 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17957 {
17958         if (ndr_flags & NDR_SCALARS) {
17959                 int level = ndr_push_get_switch_value(ndr, r);
17960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17961                 switch (level) {
17962                         case 1: {
17963                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17964                         break; }
17965
17966                         case 2: {
17967                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17968                         break; }
17969
17970                         case 3: {
17971                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17972                         break; }
17973
17974                         default:
17975                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17976                 }
17977         }
17978         if (ndr_flags & NDR_BUFFERS) {
17979                 int level = ndr_push_get_switch_value(ndr, r);
17980                 switch (level) {
17981                         case 1:
17982                                 if (r->level1) {
17983                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17984                                 }
17985                         break;
17986
17987                         case 2:
17988                                 if (r->level2) {
17989                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17990                                 }
17991                         break;
17992
17993                         case 3:
17994                                 if (r->level3) {
17995                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17996                                 }
17997                         break;
17998
17999                         default:
18000                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18001                 }
18002         }
18003         return NDR_ERR_SUCCESS;
18004 }
18005
18006 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18007 {
18008         int level;
18009         uint32_t _level;
18010         TALLOC_CTX *_mem_save_level1_0;
18011         TALLOC_CTX *_mem_save_level2_0;
18012         TALLOC_CTX *_mem_save_level3_0;
18013         level = ndr_pull_get_switch_value(ndr, r);
18014         if (ndr_flags & NDR_SCALARS) {
18015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18016                 if (_level != level) {
18017                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18018                 }
18019                 switch (level) {
18020                         case 1: {
18021                                 uint32_t _ptr_level1;
18022                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18023                                 if (_ptr_level1) {
18024                                         NDR_PULL_ALLOC(ndr, r->level1);
18025                                 } else {
18026                                         r->level1 = NULL;
18027                                 }
18028                         break; }
18029
18030                         case 2: {
18031                                 uint32_t _ptr_level2;
18032                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18033                                 if (_ptr_level2) {
18034                                         NDR_PULL_ALLOC(ndr, r->level2);
18035                                 } else {
18036                                         r->level2 = NULL;
18037                                 }
18038                         break; }
18039
18040                         case 3: {
18041                                 uint32_t _ptr_level3;
18042                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18043                                 if (_ptr_level3) {
18044                                         NDR_PULL_ALLOC(ndr, r->level3);
18045                                 } else {
18046                                         r->level3 = NULL;
18047                                 }
18048                         break; }
18049
18050                         default:
18051                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18052                 }
18053         }
18054         if (ndr_flags & NDR_BUFFERS) {
18055                 switch (level) {
18056                         case 1:
18057                                 if (r->level1) {
18058                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18059                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18060                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18061                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18062                                 }
18063                         break;
18064
18065                         case 2:
18066                                 if (r->level2) {
18067                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18068                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18069                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18070                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18071                                 }
18072                         break;
18073
18074                         case 3:
18075                                 if (r->level3) {
18076                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18077                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18078                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18079                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18080                                 }
18081                         break;
18082
18083                         default:
18084                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18085                 }
18086         }
18087         return NDR_ERR_SUCCESS;
18088 }
18089
18090 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18091 {
18092         int level;
18093         level = ndr_print_get_switch_value(ndr, r);
18094         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18095         switch (level) {
18096                 case 1:
18097                         ndr_print_ptr(ndr, "level1", r->level1);
18098                         ndr->depth++;
18099                         if (r->level1) {
18100                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18101                         }
18102                         ndr->depth--;
18103                 break;
18104
18105                 case 2:
18106                         ndr_print_ptr(ndr, "level2", r->level2);
18107                         ndr->depth++;
18108                         if (r->level2) {
18109                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18110                         }
18111                         ndr->depth--;
18112                 break;
18113
18114                 case 3:
18115                         ndr_print_ptr(ndr, "level3", r->level3);
18116                         ndr->depth++;
18117                         if (r->level3) {
18118                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18119                         }
18120                         ndr->depth--;
18121                 break;
18122
18123                 default:
18124                         ndr_print_bad_level(ndr, name, level);
18125         }
18126 }
18127
18128 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18129 {
18130         if (ndr_flags & NDR_SCALARS) {
18131                 NDR_CHECK(ndr_push_align(ndr, 4));
18132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18133                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18134                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18135         }
18136         if (ndr_flags & NDR_BUFFERS) {
18137                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18138         }
18139         return NDR_ERR_SUCCESS;
18140 }
18141
18142 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18143 {
18144         if (ndr_flags & NDR_SCALARS) {
18145                 NDR_CHECK(ndr_pull_align(ndr, 4));
18146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18147                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18148                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18149         }
18150         if (ndr_flags & NDR_BUFFERS) {
18151                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18152         }
18153         return NDR_ERR_SUCCESS;
18154 }
18155
18156 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18157 {
18158         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18159         ndr->depth++;
18160         ndr_print_uint32(ndr, "level", r->level);
18161         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18162         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18163         ndr->depth--;
18164 }
18165
18166 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18167 {
18168         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18169         return NDR_ERR_SUCCESS;
18170 }
18171
18172 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18173 {
18174         uint32_t v;
18175         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18176         *r = v;
18177         return NDR_ERR_SUCCESS;
18178 }
18179
18180 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18181 {
18182         ndr_print_uint32(ndr, name, r);
18183         ndr->depth++;
18184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18185         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18186         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18187         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18188         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18189         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18190         ndr->depth--;
18191 }
18192
18193 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18194 {
18195         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18196         return NDR_ERR_SUCCESS;
18197 }
18198
18199 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18200 {
18201         uint32_t v;
18202         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18203         *r = v;
18204         return NDR_ERR_SUCCESS;
18205 }
18206
18207 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18208 {
18209         ndr_print_uint32(ndr, name, r);
18210         ndr->depth++;
18211         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18212         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18213         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18214         ndr->depth--;
18215 }
18216
18217 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18218 {
18219         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18220         return NDR_ERR_SUCCESS;
18221 }
18222
18223 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18224 {
18225         uint32_t v;
18226         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18227         *r = v;
18228         return NDR_ERR_SUCCESS;
18229 }
18230
18231 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18232 {
18233         const char *val = NULL;
18234
18235         switch (r) {
18236                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18237                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18238         }
18239         ndr_print_enum(ndr, name, "ENUM", val, r);
18240 }
18241
18242 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18243 {
18244         if (ndr_flags & NDR_SCALARS) {
18245                 NDR_CHECK(ndr_push_align(ndr, 4));
18246                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18248                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18251                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18254                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18255                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18256                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18257                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18261         }
18262         if (ndr_flags & NDR_BUFFERS) {
18263         }
18264         return NDR_ERR_SUCCESS;
18265 }
18266
18267 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18268 {
18269         if (ndr_flags & NDR_SCALARS) {
18270                 NDR_CHECK(ndr_pull_align(ndr, 4));
18271                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18273                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18276                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18277                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18279                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18280                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18281                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18282                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18283                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18286         }
18287         if (ndr_flags & NDR_BUFFERS) {
18288         }
18289         return NDR_ERR_SUCCESS;
18290 }
18291
18292 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18293 {
18294         ndr_print_struct(ndr, name, "spoolss_PortData1");
18295         ndr->depth++;
18296         ndr_print_string(ndr, "portname", r->portname);
18297         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18298         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18299         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18300         ndr_print_uint32(ndr, "reserved", r->reserved);
18301         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18302         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18303         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18304         ndr_print_string(ndr, "queue", r->queue);
18305         ndr_print_string(ndr, "ip_address", r->ip_address);
18306         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18307         ndr_print_string(ndr, "device_type", r->device_type);
18308         ndr_print_uint32(ndr, "port_number", r->port_number);
18309         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18310         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18311         ndr->depth--;
18312 }
18313
18314 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18315 {
18316         if (ndr_flags & NDR_SCALARS) {
18317                 NDR_CHECK(ndr_push_align(ndr, 4));
18318                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18320                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18323                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18324                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18326                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18327                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18332         }
18333         if (ndr_flags & NDR_BUFFERS) {
18334         }
18335         return NDR_ERR_SUCCESS;
18336 }
18337
18338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18339 {
18340         if (ndr_flags & NDR_SCALARS) {
18341                 NDR_CHECK(ndr_pull_align(ndr, 4));
18342                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18344                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18347                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18348                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18350                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18351                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18356         }
18357         if (ndr_flags & NDR_BUFFERS) {
18358         }
18359         return NDR_ERR_SUCCESS;
18360 }
18361
18362 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18363 {
18364         ndr_print_struct(ndr, name, "spoolss_PortData2");
18365         ndr->depth++;
18366         ndr_print_string(ndr, "portname", r->portname);
18367         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18368         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18369         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18370         ndr_print_uint32(ndr, "reserved", r->reserved);
18371         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18372         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18373         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18374         ndr_print_string(ndr, "queue", r->queue);
18375         ndr_print_string(ndr, "device_type", r->device_type);
18376         ndr_print_uint32(ndr, "port_number", r->port_number);
18377         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18378         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18379         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18380         ndr->depth--;
18381 }
18382
18383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18384 {
18385         if (ndr_flags & NDR_SCALARS) {
18386                 NDR_CHECK(ndr_push_align(ndr, 4));
18387                 {
18388                         uint32_t _flags_save_string = ndr->flags;
18389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18390                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18391                         ndr->flags = _flags_save_string;
18392                 }
18393         }
18394         if (ndr_flags & NDR_BUFFERS) {
18395         }
18396         return NDR_ERR_SUCCESS;
18397 }
18398
18399 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18400 {
18401         if (ndr_flags & NDR_SCALARS) {
18402                 NDR_CHECK(ndr_pull_align(ndr, 4));
18403                 {
18404                         uint32_t _flags_save_string = ndr->flags;
18405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18406                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18407                         ndr->flags = _flags_save_string;
18408                 }
18409         }
18410         if (ndr_flags & NDR_BUFFERS) {
18411         }
18412         return NDR_ERR_SUCCESS;
18413 }
18414
18415 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18416 {
18417         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18418         ndr->depth++;
18419         ndr_print_string(ndr, "dll_name", r->dll_name);
18420         ndr->depth--;
18421 }
18422
18423 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18424 {
18425         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18426         return NDR_ERR_SUCCESS;
18427 }
18428
18429 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18430 {
18431         uint32_t v;
18432         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18433         *r = v;
18434         return NDR_ERR_SUCCESS;
18435 }
18436
18437 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18438 {
18439         ndr_print_uint32(ndr, name, r);
18440         ndr->depth++;
18441         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18442         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18449         ndr->depth--;
18450 }
18451
18452 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18453 {
18454         if (flags & NDR_IN) {
18455                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18457                 if (r->in.server) {
18458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18462                 }
18463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18465                 if (r->in.buffer) {
18466                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18467                 }
18468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18469         }
18470         if (flags & NDR_OUT) {
18471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18472                 if (r->out.info) {
18473                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18474                 }
18475                 if (r->out.needed == NULL) {
18476                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18477                 }
18478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18479                 if (r->out.count == NULL) {
18480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18481                 }
18482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18484         }
18485         return NDR_ERR_SUCCESS;
18486 }
18487
18488 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18489 {
18490         uint32_t _ptr_server;
18491         uint32_t _ptr_buffer;
18492         uint32_t _ptr_info;
18493         TALLOC_CTX *_mem_save_server_0;
18494         TALLOC_CTX *_mem_save_buffer_0;
18495         TALLOC_CTX *_mem_save_info_0;
18496         TALLOC_CTX *_mem_save_needed_0;
18497         TALLOC_CTX *_mem_save_count_0;
18498         if (flags & NDR_IN) {
18499                 ZERO_STRUCT(r->out);
18500
18501                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18503                 if (_ptr_server) {
18504                         NDR_PULL_ALLOC(ndr, r->in.server);
18505                 } else {
18506                         r->in.server = NULL;
18507                 }
18508                 if (r->in.server) {
18509                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18510                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18513                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18514                                 return 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));
18515                         }
18516                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18517                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18519                 }
18520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18522                 if (_ptr_buffer) {
18523                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18524                 } else {
18525                         r->in.buffer = NULL;
18526                 }
18527                 if (r->in.buffer) {
18528                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18529                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18530                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18531                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18532                 }
18533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18534                 NDR_PULL_ALLOC(ndr, r->out.needed);
18535                 ZERO_STRUCTP(r->out.needed);
18536                 NDR_PULL_ALLOC(ndr, r->out.count);
18537                 ZERO_STRUCTP(r->out.count);
18538         }
18539         if (flags & NDR_OUT) {
18540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18541                 if (_ptr_info) {
18542                         NDR_PULL_ALLOC(ndr, r->out.info);
18543                 } else {
18544                         r->out.info = NULL;
18545                 }
18546                 if (r->out.info) {
18547                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18548                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18549                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18551                 }
18552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18553                         NDR_PULL_ALLOC(ndr, r->out.needed);
18554                 }
18555                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18556                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18560                         NDR_PULL_ALLOC(ndr, r->out.count);
18561                 }
18562                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18567         }
18568         return NDR_ERR_SUCCESS;
18569 }
18570
18571 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18572 {
18573         uint32_t cntr_info_0;
18574         if (flags & NDR_IN) {
18575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18577         }
18578         if (flags & NDR_OUT) {
18579                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18580                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18581                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18582                 }
18583                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18584                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18585                 }
18586         }
18587         return NDR_ERR_SUCCESS;
18588 }
18589
18590 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18591 {
18592         uint32_t cntr_info_0;
18593         TALLOC_CTX *_mem_save_info_0;
18594         if (flags & NDR_IN) {
18595                 ZERO_STRUCT(r->out);
18596
18597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18599         }
18600         if (flags & NDR_OUT) {
18601                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18602                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18603                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18604                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18605                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18606                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18607                 }
18608                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18609                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18610                 }
18611                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18612         }
18613         return NDR_ERR_SUCCESS;
18614 }
18615
18616 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18617 {
18618         uint32_t cntr_info_2;
18619         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18620         ndr->depth++;
18621         if (flags & NDR_SET_VALUES) {
18622                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18623         }
18624         if (flags & NDR_IN) {
18625                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18626                 ndr->depth++;
18627                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18628                 ndr_print_ptr(ndr, "server", r->in.server);
18629                 ndr->depth++;
18630                 if (r->in.server) {
18631                         ndr_print_string(ndr, "server", r->in.server);
18632                 }
18633                 ndr->depth--;
18634                 ndr_print_uint32(ndr, "level", r->in.level);
18635                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18636                 ndr->depth++;
18637                 if (r->in.buffer) {
18638                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18639                 }
18640                 ndr->depth--;
18641                 ndr_print_uint32(ndr, "offered", r->in.offered);
18642                 ndr->depth--;
18643         }
18644         if (flags & NDR_OUT) {
18645                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18646                 ndr->depth++;
18647                 ndr_print_ptr(ndr, "count", r->out.count);
18648                 ndr->depth++;
18649                 ndr_print_uint32(ndr, "count", *r->out.count);
18650                 ndr->depth--;
18651                 ndr_print_ptr(ndr, "info", r->out.info);
18652                 ndr->depth++;
18653                 ndr_print_ptr(ndr, "info", *r->out.info);
18654                 ndr->depth++;
18655                 if (*r->out.info) {
18656                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18657                         ndr->depth++;
18658                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18659                                 char *idx_2=NULL;
18660                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18661                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18662                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18663                                         free(idx_2);
18664                                 }
18665                         }
18666                         ndr->depth--;
18667                 }
18668                 ndr->depth--;
18669                 ndr->depth--;
18670                 ndr_print_ptr(ndr, "needed", r->out.needed);
18671                 ndr->depth++;
18672                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18673                 ndr->depth--;
18674                 ndr_print_WERROR(ndr, "result", r->out.result);
18675                 ndr->depth--;
18676         }
18677         ndr->depth--;
18678 }
18679
18680 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18681 {
18682         if (flags & NDR_IN) {
18683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18684                 if (r->in.printername) {
18685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18689                 }
18690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18691                 if (r->in.datatype) {
18692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18696                 }
18697                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18698                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18699         }
18700         if (flags & NDR_OUT) {
18701                 if (r->out.handle == NULL) {
18702                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18703                 }
18704                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18705                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18706         }
18707         return NDR_ERR_SUCCESS;
18708 }
18709
18710 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18711 {
18712         uint32_t _ptr_printername;
18713         uint32_t _ptr_datatype;
18714         TALLOC_CTX *_mem_save_printername_0;
18715         TALLOC_CTX *_mem_save_datatype_0;
18716         TALLOC_CTX *_mem_save_handle_0;
18717         if (flags & NDR_IN) {
18718                 ZERO_STRUCT(r->out);
18719
18720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18721                 if (_ptr_printername) {
18722                         NDR_PULL_ALLOC(ndr, r->in.printername);
18723                 } else {
18724                         r->in.printername = NULL;
18725                 }
18726                 if (r->in.printername) {
18727                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18728                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18731                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18732                                 return 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));
18733                         }
18734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18737                 }
18738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18739                 if (_ptr_datatype) {
18740                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18741                 } else {
18742                         r->in.datatype = NULL;
18743                 }
18744                 if (r->in.datatype) {
18745                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18746                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18748                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18749                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18750                                 return 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));
18751                         }
18752                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18753                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18755                 }
18756                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18757                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18758                 NDR_PULL_ALLOC(ndr, r->out.handle);
18759                 ZERO_STRUCTP(r->out.handle);
18760         }
18761         if (flags & NDR_OUT) {
18762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18763                         NDR_PULL_ALLOC(ndr, r->out.handle);
18764                 }
18765                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18766                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18767                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18769                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18770         }
18771         return NDR_ERR_SUCCESS;
18772 }
18773
18774 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18775 {
18776         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18777         ndr->depth++;
18778         if (flags & NDR_SET_VALUES) {
18779                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18780         }
18781         if (flags & NDR_IN) {
18782                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18783                 ndr->depth++;
18784                 ndr_print_ptr(ndr, "printername", r->in.printername);
18785                 ndr->depth++;
18786                 if (r->in.printername) {
18787                         ndr_print_string(ndr, "printername", r->in.printername);
18788                 }
18789                 ndr->depth--;
18790                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18791                 ndr->depth++;
18792                 if (r->in.datatype) {
18793                         ndr_print_string(ndr, "datatype", r->in.datatype);
18794                 }
18795                 ndr->depth--;
18796                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18797                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18798                 ndr->depth--;
18799         }
18800         if (flags & NDR_OUT) {
18801                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18802                 ndr->depth++;
18803                 ndr_print_ptr(ndr, "handle", r->out.handle);
18804                 ndr->depth++;
18805                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18806                 ndr->depth--;
18807                 ndr_print_WERROR(ndr, "result", r->out.result);
18808                 ndr->depth--;
18809         }
18810         ndr->depth--;
18811 }
18812
18813 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18814 {
18815         if (flags & NDR_IN) {
18816                 if (r->in.handle == NULL) {
18817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18818                 }
18819                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18821                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18822                 if (r->in.ctr) {
18823                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18824                 }
18825                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18826         }
18827         if (flags & NDR_OUT) {
18828                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18829         }
18830         return NDR_ERR_SUCCESS;
18831 }
18832
18833 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18834 {
18835         uint32_t _ptr_ctr;
18836         TALLOC_CTX *_mem_save_handle_0;
18837         TALLOC_CTX *_mem_save_ctr_0;
18838         if (flags & NDR_IN) {
18839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18840                         NDR_PULL_ALLOC(ndr, r->in.handle);
18841                 }
18842                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18848                 if (_ptr_ctr) {
18849                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18850                 } else {
18851                         r->in.ctr = NULL;
18852                 }
18853                 if (r->in.ctr) {
18854                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18855                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18856                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18858                 }
18859                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18860         }
18861         if (flags & NDR_OUT) {
18862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18863         }
18864         return NDR_ERR_SUCCESS;
18865 }
18866
18867 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18868 {
18869         ndr_print_struct(ndr, name, "spoolss_SetJob");
18870         ndr->depth++;
18871         if (flags & NDR_SET_VALUES) {
18872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18873         }
18874         if (flags & NDR_IN) {
18875                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18876                 ndr->depth++;
18877                 ndr_print_ptr(ndr, "handle", r->in.handle);
18878                 ndr->depth++;
18879                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18880                 ndr->depth--;
18881                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18882                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18883                 ndr->depth++;
18884                 if (r->in.ctr) {
18885                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18886                 }
18887                 ndr->depth--;
18888                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18889                 ndr->depth--;
18890         }
18891         if (flags & NDR_OUT) {
18892                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18893                 ndr->depth++;
18894                 ndr_print_WERROR(ndr, "result", r->out.result);
18895                 ndr->depth--;
18896         }
18897         ndr->depth--;
18898 }
18899
18900 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18901 {
18902         if (flags & NDR_IN) {
18903                 if (r->in.handle == NULL) {
18904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18905                 }
18906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18910                 if (r->in.buffer) {
18911                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18912                 }
18913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18914         }
18915         if (flags & NDR_OUT) {
18916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18917                 if (r->out.info) {
18918                         {
18919                                 struct ndr_push *_ndr_info;
18920                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18921                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18922                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18923                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18924                         }
18925                 }
18926                 if (r->out.needed == NULL) {
18927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18928                 }
18929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18931         }
18932         return NDR_ERR_SUCCESS;
18933 }
18934
18935 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18936 {
18937         uint32_t _ptr_buffer;
18938         uint32_t _ptr_info;
18939         TALLOC_CTX *_mem_save_handle_0;
18940         TALLOC_CTX *_mem_save_buffer_0;
18941         TALLOC_CTX *_mem_save_info_0;
18942         TALLOC_CTX *_mem_save_needed_0;
18943         if (flags & NDR_IN) {
18944                 ZERO_STRUCT(r->out);
18945
18946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18947                         NDR_PULL_ALLOC(ndr, r->in.handle);
18948                 }
18949                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18950                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18951                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18955                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18956                 if (_ptr_buffer) {
18957                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18958                 } else {
18959                         r->in.buffer = NULL;
18960                 }
18961                 if (r->in.buffer) {
18962                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18963                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18964                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18966                 }
18967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18968                 NDR_PULL_ALLOC(ndr, r->out.needed);
18969                 ZERO_STRUCTP(r->out.needed);
18970         }
18971         if (flags & NDR_OUT) {
18972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18973                 if (_ptr_info) {
18974                         NDR_PULL_ALLOC(ndr, r->out.info);
18975                 } else {
18976                         r->out.info = NULL;
18977                 }
18978                 if (r->out.info) {
18979                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18980                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18981                         {
18982                                 struct ndr_pull *_ndr_info;
18983                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18984                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18985                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18986                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18987                         }
18988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18989                 }
18990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18991                         NDR_PULL_ALLOC(ndr, r->out.needed);
18992                 }
18993                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18998         }
18999         return NDR_ERR_SUCCESS;
19000 }
19001
19002 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19003 {
19004         ndr_print_struct(ndr, name, "spoolss_GetJob");
19005         ndr->depth++;
19006         if (flags & NDR_SET_VALUES) {
19007                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19008         }
19009         if (flags & NDR_IN) {
19010                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19011                 ndr->depth++;
19012                 ndr_print_ptr(ndr, "handle", r->in.handle);
19013                 ndr->depth++;
19014                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19015                 ndr->depth--;
19016                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19017                 ndr_print_uint32(ndr, "level", r->in.level);
19018                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19019                 ndr->depth++;
19020                 if (r->in.buffer) {
19021                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19022                 }
19023                 ndr->depth--;
19024                 ndr_print_uint32(ndr, "offered", r->in.offered);
19025                 ndr->depth--;
19026         }
19027         if (flags & NDR_OUT) {
19028                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19029                 ndr->depth++;
19030                 ndr_print_ptr(ndr, "info", r->out.info);
19031                 ndr->depth++;
19032                 if (r->out.info) {
19033                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19034                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19035                 }
19036                 ndr->depth--;
19037                 ndr_print_ptr(ndr, "needed", r->out.needed);
19038                 ndr->depth++;
19039                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19040                 ndr->depth--;
19041                 ndr_print_WERROR(ndr, "result", r->out.result);
19042                 ndr->depth--;
19043         }
19044         ndr->depth--;
19045 }
19046
19047 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19048 {
19049         if (flags & NDR_IN) {
19050                 if (r->in.handle == NULL) {
19051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19052                 }
19053                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19058                 if (r->in.buffer) {
19059                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19060                 }
19061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19062         }
19063         if (flags & NDR_OUT) {
19064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19065                 if (r->out.info) {
19066                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19067                 }
19068                 if (r->out.needed == NULL) {
19069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19070                 }
19071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19072                 if (r->out.count == NULL) {
19073                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19074                 }
19075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19077         }
19078         return NDR_ERR_SUCCESS;
19079 }
19080
19081 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19082 {
19083         uint32_t _ptr_buffer;
19084         uint32_t _ptr_info;
19085         TALLOC_CTX *_mem_save_handle_0;
19086         TALLOC_CTX *_mem_save_buffer_0;
19087         TALLOC_CTX *_mem_save_info_0;
19088         TALLOC_CTX *_mem_save_needed_0;
19089         TALLOC_CTX *_mem_save_count_0;
19090         if (flags & NDR_IN) {
19091                 ZERO_STRUCT(r->out);
19092
19093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19094                         NDR_PULL_ALLOC(ndr, r->in.handle);
19095                 }
19096                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19097                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19098                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19104                 if (_ptr_buffer) {
19105                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19106                 } else {
19107                         r->in.buffer = NULL;
19108                 }
19109                 if (r->in.buffer) {
19110                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19111                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19112                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19114                 }
19115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19116                 NDR_PULL_ALLOC(ndr, r->out.needed);
19117                 ZERO_STRUCTP(r->out.needed);
19118                 NDR_PULL_ALLOC(ndr, r->out.count);
19119                 ZERO_STRUCTP(r->out.count);
19120         }
19121         if (flags & NDR_OUT) {
19122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19123                 if (_ptr_info) {
19124                         NDR_PULL_ALLOC(ndr, r->out.info);
19125                 } else {
19126                         r->out.info = NULL;
19127                 }
19128                 if (r->out.info) {
19129                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19130                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19131                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19132                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19133                 }
19134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19135                         NDR_PULL_ALLOC(ndr, r->out.needed);
19136                 }
19137                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19138                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19142                         NDR_PULL_ALLOC(ndr, r->out.count);
19143                 }
19144                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19145                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19148                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19149         }
19150         return NDR_ERR_SUCCESS;
19151 }
19152
19153 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19154 {
19155         uint32_t cntr_info_0;
19156         if (flags & NDR_IN) {
19157                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19159         }
19160         if (flags & NDR_OUT) {
19161                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19162                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19163                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19164                 }
19165                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19166                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19167                 }
19168         }
19169         return NDR_ERR_SUCCESS;
19170 }
19171
19172 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19173 {
19174         uint32_t cntr_info_0;
19175         TALLOC_CTX *_mem_save_info_0;
19176         if (flags & NDR_IN) {
19177                 ZERO_STRUCT(r->out);
19178
19179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19181         }
19182         if (flags & NDR_OUT) {
19183                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19184                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19185                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19186                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19187                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19188                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19189                 }
19190                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19191                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19192                 }
19193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19194         }
19195         return NDR_ERR_SUCCESS;
19196 }
19197
19198 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19199 {
19200         uint32_t cntr_info_2;
19201         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19202         ndr->depth++;
19203         if (flags & NDR_SET_VALUES) {
19204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19205         }
19206         if (flags & NDR_IN) {
19207                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19208                 ndr->depth++;
19209                 ndr_print_ptr(ndr, "handle", r->in.handle);
19210                 ndr->depth++;
19211                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19212                 ndr->depth--;
19213                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19214                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19215                 ndr_print_uint32(ndr, "level", r->in.level);
19216                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19217                 ndr->depth++;
19218                 if (r->in.buffer) {
19219                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19220                 }
19221                 ndr->depth--;
19222                 ndr_print_uint32(ndr, "offered", r->in.offered);
19223                 ndr->depth--;
19224         }
19225         if (flags & NDR_OUT) {
19226                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19227                 ndr->depth++;
19228                 ndr_print_ptr(ndr, "count", r->out.count);
19229                 ndr->depth++;
19230                 ndr_print_uint32(ndr, "count", *r->out.count);
19231                 ndr->depth--;
19232                 ndr_print_ptr(ndr, "info", r->out.info);
19233                 ndr->depth++;
19234                 ndr_print_ptr(ndr, "info", *r->out.info);
19235                 ndr->depth++;
19236                 if (*r->out.info) {
19237                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19238                         ndr->depth++;
19239                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19240                                 char *idx_2=NULL;
19241                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19242                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19243                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19244                                         free(idx_2);
19245                                 }
19246                         }
19247                         ndr->depth--;
19248                 }
19249                 ndr->depth--;
19250                 ndr->depth--;
19251                 ndr_print_ptr(ndr, "needed", r->out.needed);
19252                 ndr->depth++;
19253                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19254                 ndr->depth--;
19255                 ndr_print_WERROR(ndr, "result", r->out.result);
19256                 ndr->depth--;
19257         }
19258         ndr->depth--;
19259 }
19260
19261 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19262 {
19263         if (flags & NDR_IN) {
19264         }
19265         if (flags & NDR_OUT) {
19266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19267         }
19268         return NDR_ERR_SUCCESS;
19269 }
19270
19271 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19272 {
19273         if (flags & NDR_IN) {
19274         }
19275         if (flags & NDR_OUT) {
19276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19277         }
19278         return NDR_ERR_SUCCESS;
19279 }
19280
19281 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19282 {
19283         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19284         ndr->depth++;
19285         if (flags & NDR_SET_VALUES) {
19286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19287         }
19288         if (flags & NDR_IN) {
19289                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19290                 ndr->depth++;
19291                 ndr->depth--;
19292         }
19293         if (flags & NDR_OUT) {
19294                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19295                 ndr->depth++;
19296                 ndr_print_WERROR(ndr, "result", r->out.result);
19297                 ndr->depth--;
19298         }
19299         ndr->depth--;
19300 }
19301
19302 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19303 {
19304         if (flags & NDR_IN) {
19305                 if (r->in.handle == NULL) {
19306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19307                 }
19308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19309         }
19310         if (flags & NDR_OUT) {
19311                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19312         }
19313         return NDR_ERR_SUCCESS;
19314 }
19315
19316 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19317 {
19318         TALLOC_CTX *_mem_save_handle_0;
19319         if (flags & NDR_IN) {
19320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19321                         NDR_PULL_ALLOC(ndr, r->in.handle);
19322                 }
19323                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19324                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19325                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19327         }
19328         if (flags & NDR_OUT) {
19329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19330         }
19331         return NDR_ERR_SUCCESS;
19332 }
19333
19334 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19335 {
19336         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19337         ndr->depth++;
19338         if (flags & NDR_SET_VALUES) {
19339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19340         }
19341         if (flags & NDR_IN) {
19342                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19343                 ndr->depth++;
19344                 ndr_print_ptr(ndr, "handle", r->in.handle);
19345                 ndr->depth++;
19346                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19347                 ndr->depth--;
19348                 ndr->depth--;
19349         }
19350         if (flags & NDR_OUT) {
19351                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19352                 ndr->depth++;
19353                 ndr_print_WERROR(ndr, "result", r->out.result);
19354                 ndr->depth--;
19355         }
19356         ndr->depth--;
19357 }
19358
19359 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19360 {
19361         if (flags & NDR_IN) {
19362                 if (r->in.handle == NULL) {
19363                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19364                 }
19365                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19366                 if (r->in.info_ctr == NULL) {
19367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19368                 }
19369                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19370                 if (r->in.devmode_ctr == NULL) {
19371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19372                 }
19373                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19374                 if (r->in.secdesc_ctr == NULL) {
19375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19376                 }
19377                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19378                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19379         }
19380         if (flags & NDR_OUT) {
19381                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19382         }
19383         return NDR_ERR_SUCCESS;
19384 }
19385
19386 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19387 {
19388         TALLOC_CTX *_mem_save_handle_0;
19389         TALLOC_CTX *_mem_save_info_ctr_0;
19390         TALLOC_CTX *_mem_save_devmode_ctr_0;
19391         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19392         if (flags & NDR_IN) {
19393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19394                         NDR_PULL_ALLOC(ndr, r->in.handle);
19395                 }
19396                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19397                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19398                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19401                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19402                 }
19403                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19404                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19405                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19407                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19408                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19409                 }
19410                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19411                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19412                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19415                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19416                 }
19417                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19418                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19419                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19421                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19422         }
19423         if (flags & NDR_OUT) {
19424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19425         }
19426         return NDR_ERR_SUCCESS;
19427 }
19428
19429 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19430 {
19431         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19432         ndr->depth++;
19433         if (flags & NDR_SET_VALUES) {
19434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19435         }
19436         if (flags & NDR_IN) {
19437                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19438                 ndr->depth++;
19439                 ndr_print_ptr(ndr, "handle", r->in.handle);
19440                 ndr->depth++;
19441                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19442                 ndr->depth--;
19443                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19444                 ndr->depth++;
19445                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19446                 ndr->depth--;
19447                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19448                 ndr->depth++;
19449                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19450                 ndr->depth--;
19451                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19452                 ndr->depth++;
19453                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19454                 ndr->depth--;
19455                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19456                 ndr->depth--;
19457         }
19458         if (flags & NDR_OUT) {
19459                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19460                 ndr->depth++;
19461                 ndr_print_WERROR(ndr, "result", r->out.result);
19462                 ndr->depth--;
19463         }
19464         ndr->depth--;
19465 }
19466
19467 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19468 {
19469         if (flags & NDR_IN) {
19470                 if (r->in.handle == NULL) {
19471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19472                 }
19473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19475                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19476                 if (r->in.buffer) {
19477                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19478                 }
19479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19480         }
19481         if (flags & NDR_OUT) {
19482                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19483                 if (r->out.info) {
19484                         {
19485                                 struct ndr_push *_ndr_info;
19486                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19487                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19488                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19489                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19490                         }
19491                 }
19492                 if (r->out.needed == NULL) {
19493                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19494                 }
19495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19497         }
19498         return NDR_ERR_SUCCESS;
19499 }
19500
19501 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19502 {
19503         uint32_t _ptr_buffer;
19504         uint32_t _ptr_info;
19505         TALLOC_CTX *_mem_save_handle_0;
19506         TALLOC_CTX *_mem_save_buffer_0;
19507         TALLOC_CTX *_mem_save_info_0;
19508         TALLOC_CTX *_mem_save_needed_0;
19509         if (flags & NDR_IN) {
19510                 ZERO_STRUCT(r->out);
19511
19512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19513                         NDR_PULL_ALLOC(ndr, r->in.handle);
19514                 }
19515                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19516                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19517                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19518                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19521                 if (_ptr_buffer) {
19522                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19523                 } else {
19524                         r->in.buffer = NULL;
19525                 }
19526                 if (r->in.buffer) {
19527                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19528                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19529                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19531                 }
19532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19533                 NDR_PULL_ALLOC(ndr, r->out.needed);
19534                 ZERO_STRUCTP(r->out.needed);
19535         }
19536         if (flags & NDR_OUT) {
19537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19538                 if (_ptr_info) {
19539                         NDR_PULL_ALLOC(ndr, r->out.info);
19540                 } else {
19541                         r->out.info = NULL;
19542                 }
19543                 if (r->out.info) {
19544                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19545                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19546                         {
19547                                 struct ndr_pull *_ndr_info;
19548                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19549                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19550                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19551                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19552                         }
19553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19554                 }
19555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19556                         NDR_PULL_ALLOC(ndr, r->out.needed);
19557                 }
19558                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19559                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19563         }
19564         return NDR_ERR_SUCCESS;
19565 }
19566
19567 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19568 {
19569         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19570         ndr->depth++;
19571         if (flags & NDR_SET_VALUES) {
19572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19573         }
19574         if (flags & NDR_IN) {
19575                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19576                 ndr->depth++;
19577                 ndr_print_ptr(ndr, "handle", r->in.handle);
19578                 ndr->depth++;
19579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19580                 ndr->depth--;
19581                 ndr_print_uint32(ndr, "level", r->in.level);
19582                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19583                 ndr->depth++;
19584                 if (r->in.buffer) {
19585                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19586                 }
19587                 ndr->depth--;
19588                 ndr_print_uint32(ndr, "offered", r->in.offered);
19589                 ndr->depth--;
19590         }
19591         if (flags & NDR_OUT) {
19592                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19593                 ndr->depth++;
19594                 ndr_print_ptr(ndr, "info", r->out.info);
19595                 ndr->depth++;
19596                 if (r->out.info) {
19597                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19598                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19599                 }
19600                 ndr->depth--;
19601                 ndr_print_ptr(ndr, "needed", r->out.needed);
19602                 ndr->depth++;
19603                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19604                 ndr->depth--;
19605                 ndr_print_WERROR(ndr, "result", r->out.result);
19606                 ndr->depth--;
19607         }
19608         ndr->depth--;
19609 }
19610
19611 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19612 {
19613         if (flags & NDR_IN) {
19614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19615                 if (r->in.servername) {
19616                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19617                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19620                 }
19621                 if (r->in.info_ctr == NULL) {
19622                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19623                 }
19624                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19625         }
19626         if (flags & NDR_OUT) {
19627                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19628         }
19629         return NDR_ERR_SUCCESS;
19630 }
19631
19632 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19633 {
19634         uint32_t _ptr_servername;
19635         TALLOC_CTX *_mem_save_servername_0;
19636         TALLOC_CTX *_mem_save_info_ctr_0;
19637         if (flags & NDR_IN) {
19638                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19639                 if (_ptr_servername) {
19640                         NDR_PULL_ALLOC(ndr, r->in.servername);
19641                 } else {
19642                         r->in.servername = NULL;
19643                 }
19644                 if (r->in.servername) {
19645                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19646                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19649                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19650                                 return 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));
19651                         }
19652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19655                 }
19656                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19657                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19658                 }
19659                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19660                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19661                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19662                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19663         }
19664         if (flags & NDR_OUT) {
19665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19666         }
19667         return NDR_ERR_SUCCESS;
19668 }
19669
19670 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19671 {
19672         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19673         ndr->depth++;
19674         if (flags & NDR_SET_VALUES) {
19675                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19676         }
19677         if (flags & NDR_IN) {
19678                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19679                 ndr->depth++;
19680                 ndr_print_ptr(ndr, "servername", r->in.servername);
19681                 ndr->depth++;
19682                 if (r->in.servername) {
19683                         ndr_print_string(ndr, "servername", r->in.servername);
19684                 }
19685                 ndr->depth--;
19686                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19687                 ndr->depth++;
19688                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19689                 ndr->depth--;
19690                 ndr->depth--;
19691         }
19692         if (flags & NDR_OUT) {
19693                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19694                 ndr->depth++;
19695                 ndr_print_WERROR(ndr, "result", r->out.result);
19696                 ndr->depth--;
19697         }
19698         ndr->depth--;
19699 }
19700
19701 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19702 {
19703         if (flags & NDR_IN) {
19704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19705                 if (r->in.server) {
19706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19710                 }
19711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19712                 if (r->in.environment) {
19713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19717                 }
19718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19720                 if (r->in.buffer) {
19721                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19722                 }
19723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19724         }
19725         if (flags & NDR_OUT) {
19726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19727                 if (r->out.info) {
19728                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19729                 }
19730                 if (r->out.needed == NULL) {
19731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19732                 }
19733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19734                 if (r->out.count == NULL) {
19735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19736                 }
19737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19739         }
19740         return NDR_ERR_SUCCESS;
19741 }
19742
19743 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19744 {
19745         uint32_t _ptr_server;
19746         uint32_t _ptr_environment;
19747         uint32_t _ptr_buffer;
19748         uint32_t _ptr_info;
19749         TALLOC_CTX *_mem_save_server_0;
19750         TALLOC_CTX *_mem_save_environment_0;
19751         TALLOC_CTX *_mem_save_buffer_0;
19752         TALLOC_CTX *_mem_save_info_0;
19753         TALLOC_CTX *_mem_save_needed_0;
19754         TALLOC_CTX *_mem_save_count_0;
19755         if (flags & NDR_IN) {
19756                 ZERO_STRUCT(r->out);
19757
19758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19759                 if (_ptr_server) {
19760                         NDR_PULL_ALLOC(ndr, r->in.server);
19761                 } else {
19762                         r->in.server = NULL;
19763                 }
19764                 if (r->in.server) {
19765                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19766                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19769                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19770                                 return 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));
19771                         }
19772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19775                 }
19776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19777                 if (_ptr_environment) {
19778                         NDR_PULL_ALLOC(ndr, r->in.environment);
19779                 } else {
19780                         r->in.environment = NULL;
19781                 }
19782                 if (r->in.environment) {
19783                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19784                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19785                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19786                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19787                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19788                                 return 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));
19789                         }
19790                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19791                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19793                 }
19794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19796                 if (_ptr_buffer) {
19797                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19798                 } else {
19799                         r->in.buffer = NULL;
19800                 }
19801                 if (r->in.buffer) {
19802                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19803                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19804                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19806                 }
19807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19808                 NDR_PULL_ALLOC(ndr, r->out.needed);
19809                 ZERO_STRUCTP(r->out.needed);
19810                 NDR_PULL_ALLOC(ndr, r->out.count);
19811                 ZERO_STRUCTP(r->out.count);
19812         }
19813         if (flags & NDR_OUT) {
19814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19815                 if (_ptr_info) {
19816                         NDR_PULL_ALLOC(ndr, r->out.info);
19817                 } else {
19818                         r->out.info = NULL;
19819                 }
19820                 if (r->out.info) {
19821                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19822                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19823                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19825                 }
19826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19827                         NDR_PULL_ALLOC(ndr, r->out.needed);
19828                 }
19829                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19830                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19834                         NDR_PULL_ALLOC(ndr, r->out.count);
19835                 }
19836                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19837                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19840                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19841         }
19842         return NDR_ERR_SUCCESS;
19843 }
19844
19845 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19846 {
19847         uint32_t cntr_info_0;
19848         if (flags & NDR_IN) {
19849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19851         }
19852         if (flags & NDR_OUT) {
19853                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19854                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19855                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19856                 }
19857                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19858                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19859                 }
19860         }
19861         return NDR_ERR_SUCCESS;
19862 }
19863
19864 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19865 {
19866         uint32_t cntr_info_0;
19867         TALLOC_CTX *_mem_save_info_0;
19868         if (flags & NDR_IN) {
19869                 ZERO_STRUCT(r->out);
19870
19871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19873         }
19874         if (flags & NDR_OUT) {
19875                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19876                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19877                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19878                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19879                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19880                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19881                 }
19882                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19883                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19884                 }
19885                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19886         }
19887         return NDR_ERR_SUCCESS;
19888 }
19889
19890 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19891 {
19892         uint32_t cntr_info_2;
19893         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19894         ndr->depth++;
19895         if (flags & NDR_SET_VALUES) {
19896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19897         }
19898         if (flags & NDR_IN) {
19899                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19900                 ndr->depth++;
19901                 ndr_print_ptr(ndr, "server", r->in.server);
19902                 ndr->depth++;
19903                 if (r->in.server) {
19904                         ndr_print_string(ndr, "server", r->in.server);
19905                 }
19906                 ndr->depth--;
19907                 ndr_print_ptr(ndr, "environment", r->in.environment);
19908                 ndr->depth++;
19909                 if (r->in.environment) {
19910                         ndr_print_string(ndr, "environment", r->in.environment);
19911                 }
19912                 ndr->depth--;
19913                 ndr_print_uint32(ndr, "level", r->in.level);
19914                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19915                 ndr->depth++;
19916                 if (r->in.buffer) {
19917                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19918                 }
19919                 ndr->depth--;
19920                 ndr_print_uint32(ndr, "offered", r->in.offered);
19921                 ndr->depth--;
19922         }
19923         if (flags & NDR_OUT) {
19924                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19925                 ndr->depth++;
19926                 ndr_print_ptr(ndr, "count", r->out.count);
19927                 ndr->depth++;
19928                 ndr_print_uint32(ndr, "count", *r->out.count);
19929                 ndr->depth--;
19930                 ndr_print_ptr(ndr, "info", r->out.info);
19931                 ndr->depth++;
19932                 ndr_print_ptr(ndr, "info", *r->out.info);
19933                 ndr->depth++;
19934                 if (*r->out.info) {
19935                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19936                         ndr->depth++;
19937                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19938                                 char *idx_2=NULL;
19939                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19940                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19941                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19942                                         free(idx_2);
19943                                 }
19944                         }
19945                         ndr->depth--;
19946                 }
19947                 ndr->depth--;
19948                 ndr->depth--;
19949                 ndr_print_ptr(ndr, "needed", r->out.needed);
19950                 ndr->depth++;
19951                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19952                 ndr->depth--;
19953                 ndr_print_WERROR(ndr, "result", r->out.result);
19954                 ndr->depth--;
19955         }
19956         ndr->depth--;
19957 }
19958
19959 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19960 {
19961         if (flags & NDR_IN) {
19962         }
19963         if (flags & NDR_OUT) {
19964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19965         }
19966         return NDR_ERR_SUCCESS;
19967 }
19968
19969 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19970 {
19971         if (flags & NDR_IN) {
19972         }
19973         if (flags & NDR_OUT) {
19974                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19975         }
19976         return NDR_ERR_SUCCESS;
19977 }
19978
19979 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19980 {
19981         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19982         ndr->depth++;
19983         if (flags & NDR_SET_VALUES) {
19984                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19985         }
19986         if (flags & NDR_IN) {
19987                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
19988                 ndr->depth++;
19989                 ndr->depth--;
19990         }
19991         if (flags & NDR_OUT) {
19992                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
19993                 ndr->depth++;
19994                 ndr_print_WERROR(ndr, "result", r->out.result);
19995                 ndr->depth--;
19996         }
19997         ndr->depth--;
19998 }
19999
20000 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20001 {
20002         if (flags & NDR_IN) {
20003                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20004                 if (r->in.server) {
20005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20007                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20008                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20009                 }
20010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20011                 if (r->in.environment) {
20012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20016                 }
20017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20019                 if (r->in.buffer) {
20020                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20021                 }
20022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20023         }
20024         if (flags & NDR_OUT) {
20025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20026                 if (r->out.info) {
20027                         {
20028                                 struct ndr_push *_ndr_info;
20029                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20030                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20031                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20032                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20033                         }
20034                 }
20035                 if (r->out.needed == NULL) {
20036                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20037                 }
20038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20039                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20040         }
20041         return NDR_ERR_SUCCESS;
20042 }
20043
20044 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20045 {
20046         uint32_t _ptr_server;
20047         uint32_t _ptr_environment;
20048         uint32_t _ptr_buffer;
20049         uint32_t _ptr_info;
20050         TALLOC_CTX *_mem_save_server_0;
20051         TALLOC_CTX *_mem_save_environment_0;
20052         TALLOC_CTX *_mem_save_buffer_0;
20053         TALLOC_CTX *_mem_save_info_0;
20054         TALLOC_CTX *_mem_save_needed_0;
20055         if (flags & NDR_IN) {
20056                 ZERO_STRUCT(r->out);
20057
20058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20059                 if (_ptr_server) {
20060                         NDR_PULL_ALLOC(ndr, r->in.server);
20061                 } else {
20062                         r->in.server = NULL;
20063                 }
20064                 if (r->in.server) {
20065                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20066                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20069                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20070                                 return 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));
20071                         }
20072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20073                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20075                 }
20076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20077                 if (_ptr_environment) {
20078                         NDR_PULL_ALLOC(ndr, r->in.environment);
20079                 } else {
20080                         r->in.environment = NULL;
20081                 }
20082                 if (r->in.environment) {
20083                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20084                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20087                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20088                                 return 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));
20089                         }
20090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20093                 }
20094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20096                 if (_ptr_buffer) {
20097                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20098                 } else {
20099                         r->in.buffer = NULL;
20100                 }
20101                 if (r->in.buffer) {
20102                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20103                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20104                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20106                 }
20107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20108                 NDR_PULL_ALLOC(ndr, r->out.needed);
20109                 ZERO_STRUCTP(r->out.needed);
20110         }
20111         if (flags & NDR_OUT) {
20112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20113                 if (_ptr_info) {
20114                         NDR_PULL_ALLOC(ndr, r->out.info);
20115                 } else {
20116                         r->out.info = NULL;
20117                 }
20118                 if (r->out.info) {
20119                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20120                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20121                         {
20122                                 struct ndr_pull *_ndr_info;
20123                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20124                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20125                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20126                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20127                         }
20128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20129                 }
20130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20131                         NDR_PULL_ALLOC(ndr, r->out.needed);
20132                 }
20133                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20134                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20137                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20138         }
20139         return NDR_ERR_SUCCESS;
20140 }
20141
20142 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20143 {
20144         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20145         ndr->depth++;
20146         if (flags & NDR_SET_VALUES) {
20147                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20148         }
20149         if (flags & NDR_IN) {
20150                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20151                 ndr->depth++;
20152                 ndr_print_ptr(ndr, "server", r->in.server);
20153                 ndr->depth++;
20154                 if (r->in.server) {
20155                         ndr_print_string(ndr, "server", r->in.server);
20156                 }
20157                 ndr->depth--;
20158                 ndr_print_ptr(ndr, "environment", r->in.environment);
20159                 ndr->depth++;
20160                 if (r->in.environment) {
20161                         ndr_print_string(ndr, "environment", r->in.environment);
20162                 }
20163                 ndr->depth--;
20164                 ndr_print_uint32(ndr, "level", r->in.level);
20165                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20166                 ndr->depth++;
20167                 if (r->in.buffer) {
20168                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20169                 }
20170                 ndr->depth--;
20171                 ndr_print_uint32(ndr, "offered", r->in.offered);
20172                 ndr->depth--;
20173         }
20174         if (flags & NDR_OUT) {
20175                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20176                 ndr->depth++;
20177                 ndr_print_ptr(ndr, "info", r->out.info);
20178                 ndr->depth++;
20179                 if (r->out.info) {
20180                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20181                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20182                 }
20183                 ndr->depth--;
20184                 ndr_print_ptr(ndr, "needed", r->out.needed);
20185                 ndr->depth++;
20186                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20187                 ndr->depth--;
20188                 ndr_print_WERROR(ndr, "result", r->out.result);
20189                 ndr->depth--;
20190         }
20191         ndr->depth--;
20192 }
20193
20194 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20195 {
20196         if (flags & NDR_IN) {
20197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20198                 if (r->in.server) {
20199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20203                 }
20204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20207                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20211                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20212         }
20213         if (flags & NDR_OUT) {
20214                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20215         }
20216         return NDR_ERR_SUCCESS;
20217 }
20218
20219 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20220 {
20221         uint32_t _ptr_server;
20222         TALLOC_CTX *_mem_save_server_0;
20223         if (flags & NDR_IN) {
20224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20225                 if (_ptr_server) {
20226                         NDR_PULL_ALLOC(ndr, r->in.server);
20227                 } else {
20228                         r->in.server = NULL;
20229                 }
20230                 if (r->in.server) {
20231                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20232                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20235                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20236                                 return 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));
20237                         }
20238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20241                 }
20242                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20243                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20244                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20245                         return 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));
20246                 }
20247                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20248                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20249                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20250                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20251                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20252                         return 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));
20253                 }
20254                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20255                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20256         }
20257         if (flags & NDR_OUT) {
20258                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20259         }
20260         return NDR_ERR_SUCCESS;
20261 }
20262
20263 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20264 {
20265         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20266         ndr->depth++;
20267         if (flags & NDR_SET_VALUES) {
20268                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20269         }
20270         if (flags & NDR_IN) {
20271                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20272                 ndr->depth++;
20273                 ndr_print_ptr(ndr, "server", r->in.server);
20274                 ndr->depth++;
20275                 if (r->in.server) {
20276                         ndr_print_string(ndr, "server", r->in.server);
20277                 }
20278                 ndr->depth--;
20279                 ndr_print_string(ndr, "architecture", r->in.architecture);
20280                 ndr_print_string(ndr, "driver", r->in.driver);
20281                 ndr->depth--;
20282         }
20283         if (flags & NDR_OUT) {
20284                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20285                 ndr->depth++;
20286                 ndr_print_WERROR(ndr, "result", r->out.result);
20287                 ndr->depth--;
20288         }
20289         ndr->depth--;
20290 }
20291
20292 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20293 {
20294         if (flags & NDR_IN) {
20295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20296                 if (r->in.server) {
20297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20300                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20301                 }
20302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20305                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20309                 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));
20310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20313                 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));
20314         }
20315         if (flags & NDR_OUT) {
20316                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20317         }
20318         return NDR_ERR_SUCCESS;
20319 }
20320
20321 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20322 {
20323         uint32_t _ptr_server;
20324         TALLOC_CTX *_mem_save_server_0;
20325         if (flags & NDR_IN) {
20326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20327                 if (_ptr_server) {
20328                         NDR_PULL_ALLOC(ndr, r->in.server);
20329                 } else {
20330                         r->in.server = NULL;
20331                 }
20332                 if (r->in.server) {
20333                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20334                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20337                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20338                                 return 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));
20339                         }
20340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20343                 }
20344                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20345                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20346                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20347                         return 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));
20348                 }
20349                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20350                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20351                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20352                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20353                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20354                         return 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));
20355                 }
20356                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20357                 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));
20358                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20359                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20360                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20361                         return 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));
20362                 }
20363                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20364                 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));
20365         }
20366         if (flags & NDR_OUT) {
20367                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20368         }
20369         return NDR_ERR_SUCCESS;
20370 }
20371
20372 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20373 {
20374         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20375         ndr->depth++;
20376         if (flags & NDR_SET_VALUES) {
20377                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20378         }
20379         if (flags & NDR_IN) {
20380                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20381                 ndr->depth++;
20382                 ndr_print_ptr(ndr, "server", r->in.server);
20383                 ndr->depth++;
20384                 if (r->in.server) {
20385                         ndr_print_string(ndr, "server", r->in.server);
20386                 }
20387                 ndr->depth--;
20388                 ndr_print_string(ndr, "architecture", r->in.architecture);
20389                 ndr_print_string(ndr, "path_name", r->in.path_name);
20390                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20391                 ndr->depth--;
20392         }
20393         if (flags & NDR_OUT) {
20394                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20395                 ndr->depth++;
20396                 ndr_print_WERROR(ndr, "result", r->out.result);
20397                 ndr->depth--;
20398         }
20399         ndr->depth--;
20400 }
20401
20402 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20403 {
20404         if (flags & NDR_IN) {
20405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20406                 if (r->in.servername) {
20407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20411                 }
20412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20413                 if (r->in.environment) {
20414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20417                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20418                 }
20419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20421                 if (r->in.buffer) {
20422                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20423                 }
20424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20425         }
20426         if (flags & NDR_OUT) {
20427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20428                 if (r->out.info) {
20429                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20430                 }
20431                 if (r->out.needed == NULL) {
20432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20433                 }
20434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20435                 if (r->out.count == NULL) {
20436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20437                 }
20438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20439                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20440         }
20441         return NDR_ERR_SUCCESS;
20442 }
20443
20444 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20445 {
20446         uint32_t _ptr_servername;
20447         uint32_t _ptr_environment;
20448         uint32_t _ptr_buffer;
20449         uint32_t _ptr_info;
20450         TALLOC_CTX *_mem_save_servername_0;
20451         TALLOC_CTX *_mem_save_environment_0;
20452         TALLOC_CTX *_mem_save_buffer_0;
20453         TALLOC_CTX *_mem_save_info_0;
20454         TALLOC_CTX *_mem_save_needed_0;
20455         TALLOC_CTX *_mem_save_count_0;
20456         if (flags & NDR_IN) {
20457                 ZERO_STRUCT(r->out);
20458
20459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20460                 if (_ptr_servername) {
20461                         NDR_PULL_ALLOC(ndr, r->in.servername);
20462                 } else {
20463                         r->in.servername = NULL;
20464                 }
20465                 if (r->in.servername) {
20466                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20470                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20471                                 return 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));
20472                         }
20473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20476                 }
20477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20478                 if (_ptr_environment) {
20479                         NDR_PULL_ALLOC(ndr, r->in.environment);
20480                 } else {
20481                         r->in.environment = NULL;
20482                 }
20483                 if (r->in.environment) {
20484                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20485                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20488                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20489                                 return 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));
20490                         }
20491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20494                 }
20495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20497                 if (_ptr_buffer) {
20498                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20499                 } else {
20500                         r->in.buffer = NULL;
20501                 }
20502                 if (r->in.buffer) {
20503                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20504                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20505                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20507                 }
20508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20509                 NDR_PULL_ALLOC(ndr, r->out.needed);
20510                 ZERO_STRUCTP(r->out.needed);
20511                 NDR_PULL_ALLOC(ndr, r->out.count);
20512                 ZERO_STRUCTP(r->out.count);
20513         }
20514         if (flags & NDR_OUT) {
20515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20516                 if (_ptr_info) {
20517                         NDR_PULL_ALLOC(ndr, r->out.info);
20518                 } else {
20519                         r->out.info = NULL;
20520                 }
20521                 if (r->out.info) {
20522                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20523                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20524                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20526                 }
20527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20528                         NDR_PULL_ALLOC(ndr, r->out.needed);
20529                 }
20530                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20531                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20534                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20535                         NDR_PULL_ALLOC(ndr, r->out.count);
20536                 }
20537                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20538                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20541                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20542         }
20543         return NDR_ERR_SUCCESS;
20544 }
20545
20546 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20547 {
20548         uint32_t cntr_info_0;
20549         if (flags & NDR_IN) {
20550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20552         }
20553         if (flags & NDR_OUT) {
20554                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20555                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20556                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20557                 }
20558                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20559                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20560                 }
20561         }
20562         return NDR_ERR_SUCCESS;
20563 }
20564
20565 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20566 {
20567         uint32_t cntr_info_0;
20568         TALLOC_CTX *_mem_save_info_0;
20569         if (flags & NDR_IN) {
20570                 ZERO_STRUCT(r->out);
20571
20572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20574         }
20575         if (flags & NDR_OUT) {
20576                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20577                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20578                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20579                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20580                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20581                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20582                 }
20583                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20584                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20585                 }
20586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20587         }
20588         return NDR_ERR_SUCCESS;
20589 }
20590
20591 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20592 {
20593         uint32_t cntr_info_2;
20594         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20595         ndr->depth++;
20596         if (flags & NDR_SET_VALUES) {
20597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20598         }
20599         if (flags & NDR_IN) {
20600                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20601                 ndr->depth++;
20602                 ndr_print_ptr(ndr, "servername", r->in.servername);
20603                 ndr->depth++;
20604                 if (r->in.servername) {
20605                         ndr_print_string(ndr, "servername", r->in.servername);
20606                 }
20607                 ndr->depth--;
20608                 ndr_print_ptr(ndr, "environment", r->in.environment);
20609                 ndr->depth++;
20610                 if (r->in.environment) {
20611                         ndr_print_string(ndr, "environment", r->in.environment);
20612                 }
20613                 ndr->depth--;
20614                 ndr_print_uint32(ndr, "level", r->in.level);
20615                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20616                 ndr->depth++;
20617                 if (r->in.buffer) {
20618                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20619                 }
20620                 ndr->depth--;
20621                 ndr_print_uint32(ndr, "offered", r->in.offered);
20622                 ndr->depth--;
20623         }
20624         if (flags & NDR_OUT) {
20625                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20626                 ndr->depth++;
20627                 ndr_print_ptr(ndr, "count", r->out.count);
20628                 ndr->depth++;
20629                 ndr_print_uint32(ndr, "count", *r->out.count);
20630                 ndr->depth--;
20631                 ndr_print_ptr(ndr, "info", r->out.info);
20632                 ndr->depth++;
20633                 ndr_print_ptr(ndr, "info", *r->out.info);
20634                 ndr->depth++;
20635                 if (*r->out.info) {
20636                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20637                         ndr->depth++;
20638                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20639                                 char *idx_2=NULL;
20640                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20641                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20642                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20643                                         free(idx_2);
20644                                 }
20645                         }
20646                         ndr->depth--;
20647                 }
20648                 ndr->depth--;
20649                 ndr->depth--;
20650                 ndr_print_ptr(ndr, "needed", r->out.needed);
20651                 ndr->depth++;
20652                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20653                 ndr->depth--;
20654                 ndr_print_WERROR(ndr, "result", r->out.result);
20655                 ndr->depth--;
20656         }
20657         ndr->depth--;
20658 }
20659
20660 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20661 {
20662         if (flags & NDR_IN) {
20663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20664                 if (r->in.server) {
20665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20669                 }
20670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20671                 if (r->in.environment) {
20672                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20675                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20676                 }
20677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20679                 if (r->in.buffer) {
20680                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20681                 }
20682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20683         }
20684         if (flags & NDR_OUT) {
20685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20686                 if (r->out.info) {
20687                         {
20688                                 struct ndr_push *_ndr_info;
20689                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20690                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20691                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20692                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20693                         }
20694                 }
20695                 if (r->out.needed == NULL) {
20696                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20697                 }
20698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20700         }
20701         return NDR_ERR_SUCCESS;
20702 }
20703
20704 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20705 {
20706         uint32_t _ptr_server;
20707         uint32_t _ptr_environment;
20708         uint32_t _ptr_buffer;
20709         uint32_t _ptr_info;
20710         TALLOC_CTX *_mem_save_server_0;
20711         TALLOC_CTX *_mem_save_environment_0;
20712         TALLOC_CTX *_mem_save_buffer_0;
20713         TALLOC_CTX *_mem_save_info_0;
20714         TALLOC_CTX *_mem_save_needed_0;
20715         if (flags & NDR_IN) {
20716                 ZERO_STRUCT(r->out);
20717
20718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20719                 if (_ptr_server) {
20720                         NDR_PULL_ALLOC(ndr, r->in.server);
20721                 } else {
20722                         r->in.server = NULL;
20723                 }
20724                 if (r->in.server) {
20725                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20726                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20727                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20728                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20729                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20730                                 return 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));
20731                         }
20732                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20733                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20734                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20735                 }
20736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20737                 if (_ptr_environment) {
20738                         NDR_PULL_ALLOC(ndr, r->in.environment);
20739                 } else {
20740                         r->in.environment = NULL;
20741                 }
20742                 if (r->in.environment) {
20743                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20744                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20745                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20746                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20747                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20748                                 return 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));
20749                         }
20750                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20751                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20753                 }
20754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20756                 if (_ptr_buffer) {
20757                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20758                 } else {
20759                         r->in.buffer = NULL;
20760                 }
20761                 if (r->in.buffer) {
20762                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20763                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20764                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20766                 }
20767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20768                 NDR_PULL_ALLOC(ndr, r->out.needed);
20769                 ZERO_STRUCTP(r->out.needed);
20770         }
20771         if (flags & NDR_OUT) {
20772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20773                 if (_ptr_info) {
20774                         NDR_PULL_ALLOC(ndr, r->out.info);
20775                 } else {
20776                         r->out.info = NULL;
20777                 }
20778                 if (r->out.info) {
20779                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20780                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20781                         {
20782                                 struct ndr_pull *_ndr_info;
20783                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20784                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20785                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20786                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20787                         }
20788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20789                 }
20790                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20791                         NDR_PULL_ALLOC(ndr, r->out.needed);
20792                 }
20793                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20794                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20796                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20797                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20798         }
20799         return NDR_ERR_SUCCESS;
20800 }
20801
20802 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20803 {
20804         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20805         ndr->depth++;
20806         if (flags & NDR_SET_VALUES) {
20807                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20808         }
20809         if (flags & NDR_IN) {
20810                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20811                 ndr->depth++;
20812                 ndr_print_ptr(ndr, "server", r->in.server);
20813                 ndr->depth++;
20814                 if (r->in.server) {
20815                         ndr_print_string(ndr, "server", r->in.server);
20816                 }
20817                 ndr->depth--;
20818                 ndr_print_ptr(ndr, "environment", r->in.environment);
20819                 ndr->depth++;
20820                 if (r->in.environment) {
20821                         ndr_print_string(ndr, "environment", r->in.environment);
20822                 }
20823                 ndr->depth--;
20824                 ndr_print_uint32(ndr, "level", r->in.level);
20825                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20826                 ndr->depth++;
20827                 if (r->in.buffer) {
20828                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20829                 }
20830                 ndr->depth--;
20831                 ndr_print_uint32(ndr, "offered", r->in.offered);
20832                 ndr->depth--;
20833         }
20834         if (flags & NDR_OUT) {
20835                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20836                 ndr->depth++;
20837                 ndr_print_ptr(ndr, "info", r->out.info);
20838                 ndr->depth++;
20839                 if (r->out.info) {
20840                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20841                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20842                 }
20843                 ndr->depth--;
20844                 ndr_print_ptr(ndr, "needed", r->out.needed);
20845                 ndr->depth++;
20846                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20847                 ndr->depth--;
20848                 ndr_print_WERROR(ndr, "result", r->out.result);
20849                 ndr->depth--;
20850         }
20851         ndr->depth--;
20852 }
20853
20854 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20855 {
20856         if (flags & NDR_IN) {
20857                 if (r->in.handle == NULL) {
20858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20859                 }
20860                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20862                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20863                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20864         }
20865         if (flags & NDR_OUT) {
20866                 if (r->out.job_id == NULL) {
20867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20868                 }
20869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20870                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20871         }
20872         return NDR_ERR_SUCCESS;
20873 }
20874
20875 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20876 {
20877         TALLOC_CTX *_mem_save_handle_0;
20878         TALLOC_CTX *_mem_save_job_id_0;
20879         if (flags & NDR_IN) {
20880                 ZERO_STRUCT(r->out);
20881
20882                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20883                         NDR_PULL_ALLOC(ndr, r->in.handle);
20884                 }
20885                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20886                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20887                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20890                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20891                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20892                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20893                 ZERO_STRUCTP(r->out.job_id);
20894         }
20895         if (flags & NDR_OUT) {
20896                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20897                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20898                 }
20899                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20900                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20904         }
20905         return NDR_ERR_SUCCESS;
20906 }
20907
20908 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20909 {
20910         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20911         ndr->depth++;
20912         if (flags & NDR_SET_VALUES) {
20913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20914         }
20915         if (flags & NDR_IN) {
20916                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20917                 ndr->depth++;
20918                 ndr_print_ptr(ndr, "handle", r->in.handle);
20919                 ndr->depth++;
20920                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20921                 ndr->depth--;
20922                 ndr_print_uint32(ndr, "level", r->in.level);
20923                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20924                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20925                 ndr->depth--;
20926         }
20927         if (flags & NDR_OUT) {
20928                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20929                 ndr->depth++;
20930                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20931                 ndr->depth++;
20932                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20933                 ndr->depth--;
20934                 ndr_print_WERROR(ndr, "result", r->out.result);
20935                 ndr->depth--;
20936         }
20937         ndr->depth--;
20938 }
20939
20940 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20941 {
20942         if (flags & NDR_IN) {
20943                 if (r->in.handle == NULL) {
20944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20945                 }
20946                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20947         }
20948         if (flags & NDR_OUT) {
20949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20950         }
20951         return NDR_ERR_SUCCESS;
20952 }
20953
20954 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20955 {
20956         TALLOC_CTX *_mem_save_handle_0;
20957         if (flags & NDR_IN) {
20958                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20959                         NDR_PULL_ALLOC(ndr, r->in.handle);
20960                 }
20961                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20962                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20963                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20965         }
20966         if (flags & NDR_OUT) {
20967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20968         }
20969         return NDR_ERR_SUCCESS;
20970 }
20971
20972 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20973 {
20974         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20975         ndr->depth++;
20976         if (flags & NDR_SET_VALUES) {
20977                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20978         }
20979         if (flags & NDR_IN) {
20980                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20981                 ndr->depth++;
20982                 ndr_print_ptr(ndr, "handle", r->in.handle);
20983                 ndr->depth++;
20984                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20985                 ndr->depth--;
20986                 ndr->depth--;
20987         }
20988         if (flags & NDR_OUT) {
20989                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
20990                 ndr->depth++;
20991                 ndr_print_WERROR(ndr, "result", r->out.result);
20992                 ndr->depth--;
20993         }
20994         ndr->depth--;
20995 }
20996
20997 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
20998 {
20999         if (flags & NDR_IN) {
21000                 if (r->in.handle == NULL) {
21001                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21002                 }
21003                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21004                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21006         }
21007         if (flags & NDR_OUT) {
21008                 if (r->out.num_written == NULL) {
21009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21010                 }
21011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21013         }
21014         return NDR_ERR_SUCCESS;
21015 }
21016
21017 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21018 {
21019         TALLOC_CTX *_mem_save_handle_0;
21020         TALLOC_CTX *_mem_save_num_written_0;
21021         if (flags & NDR_IN) {
21022                 ZERO_STRUCT(r->out);
21023
21024                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21025                         NDR_PULL_ALLOC(ndr, r->in.handle);
21026                 }
21027                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21028                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21029                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21031                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21033                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21034                 ZERO_STRUCTP(r->out.num_written);
21035         }
21036         if (flags & NDR_OUT) {
21037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21038                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21039                 }
21040                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21042                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21045         }
21046         return NDR_ERR_SUCCESS;
21047 }
21048
21049 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21050 {
21051         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21052         ndr->depth++;
21053         if (flags & NDR_SET_VALUES) {
21054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21055         }
21056         if (flags & NDR_IN) {
21057                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21058                 ndr->depth++;
21059                 ndr_print_ptr(ndr, "handle", r->in.handle);
21060                 ndr->depth++;
21061                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21062                 ndr->depth--;
21063                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21064                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21065                 ndr->depth--;
21066         }
21067         if (flags & NDR_OUT) {
21068                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21069                 ndr->depth++;
21070                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21071                 ndr->depth++;
21072                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21073                 ndr->depth--;
21074                 ndr_print_WERROR(ndr, "result", r->out.result);
21075                 ndr->depth--;
21076         }
21077         ndr->depth--;
21078 }
21079
21080 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21081 {
21082         if (flags & NDR_IN) {
21083                 if (r->in.handle == NULL) {
21084                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21085                 }
21086                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21087         }
21088         if (flags & NDR_OUT) {
21089                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21090         }
21091         return NDR_ERR_SUCCESS;
21092 }
21093
21094 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21095 {
21096         TALLOC_CTX *_mem_save_handle_0;
21097         if (flags & NDR_IN) {
21098                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21099                         NDR_PULL_ALLOC(ndr, r->in.handle);
21100                 }
21101                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21102                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21103                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21105         }
21106         if (flags & NDR_OUT) {
21107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21108         }
21109         return NDR_ERR_SUCCESS;
21110 }
21111
21112 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21113 {
21114         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21115         ndr->depth++;
21116         if (flags & NDR_SET_VALUES) {
21117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21118         }
21119         if (flags & NDR_IN) {
21120                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21121                 ndr->depth++;
21122                 ndr_print_ptr(ndr, "handle", r->in.handle);
21123                 ndr->depth++;
21124                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21125                 ndr->depth--;
21126                 ndr->depth--;
21127         }
21128         if (flags & NDR_OUT) {
21129                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21130                 ndr->depth++;
21131                 ndr_print_WERROR(ndr, "result", r->out.result);
21132                 ndr->depth--;
21133         }
21134         ndr->depth--;
21135 }
21136
21137 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21138 {
21139         if (flags & NDR_IN) {
21140                 if (r->in.handle == NULL) {
21141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21142                 }
21143                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21144         }
21145         if (flags & NDR_OUT) {
21146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21147         }
21148         return NDR_ERR_SUCCESS;
21149 }
21150
21151 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21152 {
21153         TALLOC_CTX *_mem_save_handle_0;
21154         if (flags & NDR_IN) {
21155                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21156                         NDR_PULL_ALLOC(ndr, r->in.handle);
21157                 }
21158                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21159                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21160                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21162         }
21163         if (flags & NDR_OUT) {
21164                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21165         }
21166         return NDR_ERR_SUCCESS;
21167 }
21168
21169 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21170 {
21171         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21172         ndr->depth++;
21173         if (flags & NDR_SET_VALUES) {
21174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21175         }
21176         if (flags & NDR_IN) {
21177                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21178                 ndr->depth++;
21179                 ndr_print_ptr(ndr, "handle", r->in.handle);
21180                 ndr->depth++;
21181                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21182                 ndr->depth--;
21183                 ndr->depth--;
21184         }
21185         if (flags & NDR_OUT) {
21186                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21187                 ndr->depth++;
21188                 ndr_print_WERROR(ndr, "result", r->out.result);
21189                 ndr->depth--;
21190         }
21191         ndr->depth--;
21192 }
21193
21194 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21195 {
21196         if (flags & NDR_IN) {
21197                 if (r->in.handle == NULL) {
21198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21199                 }
21200                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21202         }
21203         if (flags & NDR_OUT) {
21204                 if (r->out.data == NULL) {
21205                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21206                 }
21207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21208                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21209                 if (r->out._data_size == NULL) {
21210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21211                 }
21212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21214         }
21215         return NDR_ERR_SUCCESS;
21216 }
21217
21218 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21219 {
21220         TALLOC_CTX *_mem_save_handle_0;
21221         TALLOC_CTX *_mem_save__data_size_0;
21222         if (flags & NDR_IN) {
21223                 ZERO_STRUCT(r->out);
21224
21225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21226                         NDR_PULL_ALLOC(ndr, r->in.handle);
21227                 }
21228                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21229                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21230                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21233                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21234                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21235                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21236                 ZERO_STRUCTP(r->out._data_size);
21237         }
21238         if (flags & NDR_OUT) {
21239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21240                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21241                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21242                 }
21243                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21245                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21246                 }
21247                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21248                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21251                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21252                 if (r->out.data) {
21253                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21254                 }
21255         }
21256         return NDR_ERR_SUCCESS;
21257 }
21258
21259 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21260 {
21261         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21262         ndr->depth++;
21263         if (flags & NDR_SET_VALUES) {
21264                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21265         }
21266         if (flags & NDR_IN) {
21267                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21268                 ndr->depth++;
21269                 ndr_print_ptr(ndr, "handle", r->in.handle);
21270                 ndr->depth++;
21271                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21272                 ndr->depth--;
21273                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21274                 ndr->depth--;
21275         }
21276         if (flags & NDR_OUT) {
21277                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21278                 ndr->depth++;
21279                 ndr_print_ptr(ndr, "data", r->out.data);
21280                 ndr->depth++;
21281                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21282                 ndr->depth--;
21283                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21284                 ndr->depth++;
21285                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21286                 ndr->depth--;
21287                 ndr_print_WERROR(ndr, "result", r->out.result);
21288                 ndr->depth--;
21289         }
21290         ndr->depth--;
21291 }
21292
21293 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21294 {
21295         if (flags & NDR_IN) {
21296                 if (r->in.handle == NULL) {
21297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21298                 }
21299                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21300         }
21301         if (flags & NDR_OUT) {
21302                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21303         }
21304         return NDR_ERR_SUCCESS;
21305 }
21306
21307 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21308 {
21309         TALLOC_CTX *_mem_save_handle_0;
21310         if (flags & NDR_IN) {
21311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21312                         NDR_PULL_ALLOC(ndr, r->in.handle);
21313                 }
21314                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21316                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21318         }
21319         if (flags & NDR_OUT) {
21320                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21321         }
21322         return NDR_ERR_SUCCESS;
21323 }
21324
21325 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21326 {
21327         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21328         ndr->depth++;
21329         if (flags & NDR_SET_VALUES) {
21330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21331         }
21332         if (flags & NDR_IN) {
21333                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21334                 ndr->depth++;
21335                 ndr_print_ptr(ndr, "handle", r->in.handle);
21336                 ndr->depth++;
21337                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21338                 ndr->depth--;
21339                 ndr->depth--;
21340         }
21341         if (flags & NDR_OUT) {
21342                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21343                 ndr->depth++;
21344                 ndr_print_WERROR(ndr, "result", r->out.result);
21345                 ndr->depth--;
21346         }
21347         ndr->depth--;
21348 }
21349
21350 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21351 {
21352         if (flags & NDR_IN) {
21353                 if (r->in.handle == NULL) {
21354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21355                 }
21356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21359                 if (r->in.buffer) {
21360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21361                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
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.buffer));
21367                 if (r->out.buffer) {
21368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21369                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21370                 }
21371                 if (r->out.needed == NULL) {
21372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21373                 }
21374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21375                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21376         }
21377         return NDR_ERR_SUCCESS;
21378 }
21379
21380 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21381 {
21382         uint32_t _ptr_buffer;
21383         TALLOC_CTX *_mem_save_handle_0;
21384         TALLOC_CTX *_mem_save_buffer_0;
21385         TALLOC_CTX *_mem_save_needed_0;
21386         if (flags & NDR_IN) {
21387                 ZERO_STRUCT(r->out);
21388
21389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21390                         NDR_PULL_ALLOC(ndr, r->in.handle);
21391                 }
21392                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21394                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21398                 if (_ptr_buffer) {
21399                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21400                 } else {
21401                         r->in.buffer = NULL;
21402                 }
21403                 if (r->in.buffer) {
21404                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21405                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21407                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21408                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21410                 }
21411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21412                 NDR_PULL_ALLOC(ndr, r->out.needed);
21413                 ZERO_STRUCTP(r->out.needed);
21414                 if (r->in.buffer) {
21415                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21416                 }
21417         }
21418         if (flags & NDR_OUT) {
21419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21420                 if (_ptr_buffer) {
21421                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21422                 } else {
21423                         r->out.buffer = NULL;
21424                 }
21425                 if (r->out.buffer) {
21426                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21427                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21428                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21429                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21430                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21432                 }
21433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21434                         NDR_PULL_ALLOC(ndr, r->out.needed);
21435                 }
21436                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21437                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21439                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21440                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21441                 if (r->out.buffer) {
21442                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21443                 }
21444         }
21445         return NDR_ERR_SUCCESS;
21446 }
21447
21448 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21449 {
21450         ndr_print_struct(ndr, name, "spoolss_AddJob");
21451         ndr->depth++;
21452         if (flags & NDR_SET_VALUES) {
21453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21454         }
21455         if (flags & NDR_IN) {
21456                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21457                 ndr->depth++;
21458                 ndr_print_ptr(ndr, "handle", r->in.handle);
21459                 ndr->depth++;
21460                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21461                 ndr->depth--;
21462                 ndr_print_uint32(ndr, "level", r->in.level);
21463                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21464                 ndr->depth++;
21465                 if (r->in.buffer) {
21466                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21467                 }
21468                 ndr->depth--;
21469                 ndr_print_uint32(ndr, "offered", r->in.offered);
21470                 ndr->depth--;
21471         }
21472         if (flags & NDR_OUT) {
21473                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21474                 ndr->depth++;
21475                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21476                 ndr->depth++;
21477                 if (r->out.buffer) {
21478                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21479                 }
21480                 ndr->depth--;
21481                 ndr_print_ptr(ndr, "needed", r->out.needed);
21482                 ndr->depth++;
21483                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21484                 ndr->depth--;
21485                 ndr_print_WERROR(ndr, "result", r->out.result);
21486                 ndr->depth--;
21487         }
21488         ndr->depth--;
21489 }
21490
21491 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21492 {
21493         if (flags & NDR_IN) {
21494                 if (r->in.handle == NULL) {
21495                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21496                 }
21497                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21499         }
21500         if (flags & NDR_OUT) {
21501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21502         }
21503         return NDR_ERR_SUCCESS;
21504 }
21505
21506 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21507 {
21508         TALLOC_CTX *_mem_save_handle_0;
21509         if (flags & NDR_IN) {
21510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21511                         NDR_PULL_ALLOC(ndr, r->in.handle);
21512                 }
21513                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21514                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21515                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21518         }
21519         if (flags & NDR_OUT) {
21520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21521         }
21522         return NDR_ERR_SUCCESS;
21523 }
21524
21525 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21526 {
21527         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21528         ndr->depth++;
21529         if (flags & NDR_SET_VALUES) {
21530                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21531         }
21532         if (flags & NDR_IN) {
21533                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21534                 ndr->depth++;
21535                 ndr_print_ptr(ndr, "handle", r->in.handle);
21536                 ndr->depth++;
21537                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21538                 ndr->depth--;
21539                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21540                 ndr->depth--;
21541         }
21542         if (flags & NDR_OUT) {
21543                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21544                 ndr->depth++;
21545                 ndr_print_WERROR(ndr, "result", r->out.result);
21546                 ndr->depth--;
21547         }
21548         ndr->depth--;
21549 }
21550
21551 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21552 {
21553         if (flags & NDR_IN) {
21554                 if (r->in.handle == NULL) {
21555                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21556                 }
21557                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21561                 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));
21562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21563         }
21564         if (flags & NDR_OUT) {
21565                 if (r->out.type == NULL) {
21566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21567                 }
21568                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21569                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21570                 if (r->out.needed == NULL) {
21571                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21572                 }
21573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21575         }
21576         return NDR_ERR_SUCCESS;
21577 }
21578
21579 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21580 {
21581         TALLOC_CTX *_mem_save_handle_0;
21582         TALLOC_CTX *_mem_save_type_0;
21583         TALLOC_CTX *_mem_save_needed_0;
21584         if (flags & NDR_IN) {
21585                 ZERO_STRUCT(r->out);
21586
21587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21588                         NDR_PULL_ALLOC(ndr, r->in.handle);
21589                 }
21590                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21591                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21592                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21594                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21595                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21596                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21597                         return 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));
21598                 }
21599                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21600                 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));
21601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21602                 NDR_PULL_ALLOC(ndr, r->out.type);
21603                 ZERO_STRUCTP(r->out.type);
21604                 NDR_PULL_ALLOC(ndr, r->out.needed);
21605                 ZERO_STRUCTP(r->out.needed);
21606         }
21607         if (flags & NDR_OUT) {
21608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21609                         NDR_PULL_ALLOC(ndr, r->out.type);
21610                 }
21611                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21613                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21615                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21617                         NDR_PULL_ALLOC(ndr, r->out.needed);
21618                 }
21619                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21623                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21624         }
21625         return NDR_ERR_SUCCESS;
21626 }
21627
21628 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21629 {
21630         if (flags & NDR_IN) {
21631                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21632         }
21633         if (flags & NDR_OUT) {
21634                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21635                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21636         }
21637         return NDR_ERR_SUCCESS;
21638 }
21639
21640 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21641 {
21642         if (flags & NDR_IN) {
21643                 ZERO_STRUCT(r->out);
21644
21645                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21646         }
21647         if (flags & NDR_OUT) {
21648                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21649                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21650         }
21651         return NDR_ERR_SUCCESS;
21652 }
21653
21654 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21655 {
21656         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21657         ndr->depth++;
21658         if (flags & NDR_SET_VALUES) {
21659                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21660         }
21661         if (flags & NDR_IN) {
21662                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21663                 ndr->depth++;
21664                 ndr_print_ptr(ndr, "handle", r->in.handle);
21665                 ndr->depth++;
21666                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21667                 ndr->depth--;
21668                 ndr_print_string(ndr, "value_name", r->in.value_name);
21669                 ndr_print_uint32(ndr, "offered", r->in.offered);
21670                 ndr->depth--;
21671         }
21672         if (flags & NDR_OUT) {
21673                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21674                 ndr->depth++;
21675                 ndr_print_ptr(ndr, "type", r->out.type);
21676                 ndr->depth++;
21677                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21678                 ndr->depth--;
21679                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21680                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21681                 ndr_print_ptr(ndr, "needed", r->out.needed);
21682                 ndr->depth++;
21683                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21684                 ndr->depth--;
21685                 ndr_print_WERROR(ndr, "result", r->out.result);
21686                 ndr->depth--;
21687         }
21688         ndr->depth--;
21689 }
21690
21691 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21692 {
21693         if (flags & NDR_IN) {
21694                 if (r->in.handle == NULL) {
21695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21696                 }
21697                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21701                 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));
21702                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21703                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21705         }
21706         if (flags & NDR_OUT) {
21707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21708         }
21709         return NDR_ERR_SUCCESS;
21710 }
21711
21712 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21713 {
21714         if (flags & NDR_IN) {
21715                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21716         }
21717         if (flags & NDR_OUT) {
21718                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21719                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21720         }
21721         return NDR_ERR_SUCCESS;
21722 }
21723
21724 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21725 {
21726         TALLOC_CTX *_mem_save_handle_0;
21727         if (flags & NDR_IN) {
21728                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21729                         NDR_PULL_ALLOC(ndr, r->in.handle);
21730                 }
21731                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21732                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21733                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21735                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21736                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21737                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21738                         return 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));
21739                 }
21740                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21741                 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));
21742                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21743                 {
21744                         struct ndr_pull *_ndr_data;
21745                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21746                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21747                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21748                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21749                 }
21750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21751         }
21752         if (flags & NDR_OUT) {
21753                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21754         }
21755         return NDR_ERR_SUCCESS;
21756 }
21757
21758 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21759 {
21760         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21761         ndr->depth++;
21762         if (flags & NDR_SET_VALUES) {
21763                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21764         }
21765         if (flags & NDR_IN) {
21766                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21767                 ndr->depth++;
21768                 ndr_print_ptr(ndr, "handle", r->in.handle);
21769                 ndr->depth++;
21770                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21771                 ndr->depth--;
21772                 ndr_print_string(ndr, "value_name", r->in.value_name);
21773                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21774                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21775                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21776                 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);
21777                 ndr->depth--;
21778         }
21779         if (flags & NDR_OUT) {
21780                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21781                 ndr->depth++;
21782                 ndr_print_WERROR(ndr, "result", r->out.result);
21783                 ndr->depth--;
21784         }
21785         ndr->depth--;
21786 }
21787
21788 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21789 {
21790         if (flags & NDR_IN) {
21791         }
21792         if (flags & NDR_OUT) {
21793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21794         }
21795         return NDR_ERR_SUCCESS;
21796 }
21797
21798 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21799 {
21800         if (flags & NDR_IN) {
21801         }
21802         if (flags & NDR_OUT) {
21803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21804         }
21805         return NDR_ERR_SUCCESS;
21806 }
21807
21808 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21809 {
21810         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21811         ndr->depth++;
21812         if (flags & NDR_SET_VALUES) {
21813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21814         }
21815         if (flags & NDR_IN) {
21816                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21817                 ndr->depth++;
21818                 ndr->depth--;
21819         }
21820         if (flags & NDR_OUT) {
21821                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21822                 ndr->depth++;
21823                 ndr_print_WERROR(ndr, "result", r->out.result);
21824                 ndr->depth--;
21825         }
21826         ndr->depth--;
21827 }
21828
21829 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21830 {
21831         if (flags & NDR_IN) {
21832                 if (r->in.handle == NULL) {
21833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21834                 }
21835                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21836         }
21837         if (flags & NDR_OUT) {
21838                 if (r->out.handle == NULL) {
21839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21840                 }
21841                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21842                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21843         }
21844         return NDR_ERR_SUCCESS;
21845 }
21846
21847 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21848 {
21849         TALLOC_CTX *_mem_save_handle_0;
21850         if (flags & NDR_IN) {
21851                 ZERO_STRUCT(r->out);
21852
21853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21854                         NDR_PULL_ALLOC(ndr, r->in.handle);
21855                 }
21856                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21857                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21860                 NDR_PULL_ALLOC(ndr, r->out.handle);
21861                 *r->out.handle = *r->in.handle;
21862         }
21863         if (flags & NDR_OUT) {
21864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21865                         NDR_PULL_ALLOC(ndr, r->out.handle);
21866                 }
21867                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21868                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21869                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21871                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21872         }
21873         return NDR_ERR_SUCCESS;
21874 }
21875
21876 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21877 {
21878         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21879         ndr->depth++;
21880         if (flags & NDR_SET_VALUES) {
21881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21882         }
21883         if (flags & NDR_IN) {
21884                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21885                 ndr->depth++;
21886                 ndr_print_ptr(ndr, "handle", r->in.handle);
21887                 ndr->depth++;
21888                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21889                 ndr->depth--;
21890                 ndr->depth--;
21891         }
21892         if (flags & NDR_OUT) {
21893                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21894                 ndr->depth++;
21895                 ndr_print_ptr(ndr, "handle", r->out.handle);
21896                 ndr->depth++;
21897                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21898                 ndr->depth--;
21899                 ndr_print_WERROR(ndr, "result", r->out.result);
21900                 ndr->depth--;
21901         }
21902         ndr->depth--;
21903 }
21904
21905 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21906 {
21907         if (flags & NDR_IN) {
21908                 if (r->in.handle == NULL) {
21909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21910                 }
21911                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21913                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21914                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21915         }
21916         if (flags & NDR_OUT) {
21917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21918         }
21919         return NDR_ERR_SUCCESS;
21920 }
21921
21922 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21923 {
21924         TALLOC_CTX *_mem_save_handle_0;
21925         if (flags & NDR_IN) {
21926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21927                         NDR_PULL_ALLOC(ndr, r->in.handle);
21928                 }
21929                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21930                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21931                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21934                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21935                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21936         }
21937         if (flags & NDR_OUT) {
21938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21939         }
21940         return NDR_ERR_SUCCESS;
21941 }
21942
21943 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21944 {
21945         ndr_print_struct(ndr, name, "spoolss_AddForm");
21946         ndr->depth++;
21947         if (flags & NDR_SET_VALUES) {
21948                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21949         }
21950         if (flags & NDR_IN) {
21951                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21952                 ndr->depth++;
21953                 ndr_print_ptr(ndr, "handle", r->in.handle);
21954                 ndr->depth++;
21955                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21956                 ndr->depth--;
21957                 ndr_print_uint32(ndr, "level", r->in.level);
21958                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21959                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
21960                 ndr->depth--;
21961         }
21962         if (flags & NDR_OUT) {
21963                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
21964                 ndr->depth++;
21965                 ndr_print_WERROR(ndr, "result", r->out.result);
21966                 ndr->depth--;
21967         }
21968         ndr->depth--;
21969 }
21970
21971 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
21972 {
21973         if (flags & NDR_IN) {
21974                 if (r->in.handle == NULL) {
21975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21976                 }
21977                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21981                 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));
21982         }
21983         if (flags & NDR_OUT) {
21984                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21985         }
21986         return NDR_ERR_SUCCESS;
21987 }
21988
21989 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
21990 {
21991         TALLOC_CTX *_mem_save_handle_0;
21992         if (flags & NDR_IN) {
21993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21994                         NDR_PULL_ALLOC(ndr, r->in.handle);
21995                 }
21996                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21997                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21998                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22000                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22001                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22002                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22003                         return 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));
22004                 }
22005                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22006                 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));
22007         }
22008         if (flags & NDR_OUT) {
22009                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22010         }
22011         return NDR_ERR_SUCCESS;
22012 }
22013
22014 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22015 {
22016         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22017         ndr->depth++;
22018         if (flags & NDR_SET_VALUES) {
22019                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22020         }
22021         if (flags & NDR_IN) {
22022                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22023                 ndr->depth++;
22024                 ndr_print_ptr(ndr, "handle", r->in.handle);
22025                 ndr->depth++;
22026                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22027                 ndr->depth--;
22028                 ndr_print_string(ndr, "form_name", r->in.form_name);
22029                 ndr->depth--;
22030         }
22031         if (flags & NDR_OUT) {
22032                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22033                 ndr->depth++;
22034                 ndr_print_WERROR(ndr, "result", r->out.result);
22035                 ndr->depth--;
22036         }
22037         ndr->depth--;
22038 }
22039
22040 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22041 {
22042         if (flags & NDR_IN) {
22043                 if (r->in.handle == NULL) {
22044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22045                 }
22046                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22050                 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));
22051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22053                 if (r->in.buffer) {
22054                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22055                 }
22056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22057         }
22058         if (flags & NDR_OUT) {
22059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22060                 if (r->out.info) {
22061                         {
22062                                 struct ndr_push *_ndr_info;
22063                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22064                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22065                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22066                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22067                         }
22068                 }
22069                 if (r->out.needed == NULL) {
22070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22071                 }
22072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22073                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22074         }
22075         return NDR_ERR_SUCCESS;
22076 }
22077
22078 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22079 {
22080         uint32_t _ptr_buffer;
22081         uint32_t _ptr_info;
22082         TALLOC_CTX *_mem_save_handle_0;
22083         TALLOC_CTX *_mem_save_buffer_0;
22084         TALLOC_CTX *_mem_save_info_0;
22085         TALLOC_CTX *_mem_save_needed_0;
22086         if (flags & NDR_IN) {
22087                 ZERO_STRUCT(r->out);
22088
22089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22090                         NDR_PULL_ALLOC(ndr, r->in.handle);
22091                 }
22092                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22093                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22094                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22095                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22096                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22097                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22098                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22099                         return 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));
22100                 }
22101                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22102                 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));
22103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22105                 if (_ptr_buffer) {
22106                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22107                 } else {
22108                         r->in.buffer = NULL;
22109                 }
22110                 if (r->in.buffer) {
22111                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22112                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22113                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22115                 }
22116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22117                 NDR_PULL_ALLOC(ndr, r->out.needed);
22118                 ZERO_STRUCTP(r->out.needed);
22119         }
22120         if (flags & NDR_OUT) {
22121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22122                 if (_ptr_info) {
22123                         NDR_PULL_ALLOC(ndr, r->out.info);
22124                 } else {
22125                         r->out.info = NULL;
22126                 }
22127                 if (r->out.info) {
22128                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22129                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22130                         {
22131                                 struct ndr_pull *_ndr_info;
22132                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22133                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22134                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22135                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22136                         }
22137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22138                 }
22139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22140                         NDR_PULL_ALLOC(ndr, r->out.needed);
22141                 }
22142                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22143                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22144                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22146                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22147         }
22148         return NDR_ERR_SUCCESS;
22149 }
22150
22151 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22152 {
22153         ndr_print_struct(ndr, name, "spoolss_GetForm");
22154         ndr->depth++;
22155         if (flags & NDR_SET_VALUES) {
22156                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22157         }
22158         if (flags & NDR_IN) {
22159                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22160                 ndr->depth++;
22161                 ndr_print_ptr(ndr, "handle", r->in.handle);
22162                 ndr->depth++;
22163                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22164                 ndr->depth--;
22165                 ndr_print_string(ndr, "form_name", r->in.form_name);
22166                 ndr_print_uint32(ndr, "level", r->in.level);
22167                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22168                 ndr->depth++;
22169                 if (r->in.buffer) {
22170                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22171                 }
22172                 ndr->depth--;
22173                 ndr_print_uint32(ndr, "offered", r->in.offered);
22174                 ndr->depth--;
22175         }
22176         if (flags & NDR_OUT) {
22177                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22178                 ndr->depth++;
22179                 ndr_print_ptr(ndr, "info", r->out.info);
22180                 ndr->depth++;
22181                 if (r->out.info) {
22182                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22183                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22184                 }
22185                 ndr->depth--;
22186                 ndr_print_ptr(ndr, "needed", r->out.needed);
22187                 ndr->depth++;
22188                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22189                 ndr->depth--;
22190                 ndr_print_WERROR(ndr, "result", r->out.result);
22191                 ndr->depth--;
22192         }
22193         ndr->depth--;
22194 }
22195
22196 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22197 {
22198         if (flags & NDR_IN) {
22199                 if (r->in.handle == NULL) {
22200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22201                 }
22202                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22206                 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));
22207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22208                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22209                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22210         }
22211         if (flags & NDR_OUT) {
22212                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22213         }
22214         return NDR_ERR_SUCCESS;
22215 }
22216
22217 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22218 {
22219         TALLOC_CTX *_mem_save_handle_0;
22220         if (flags & NDR_IN) {
22221                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22222                         NDR_PULL_ALLOC(ndr, r->in.handle);
22223                 }
22224                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22225                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22226                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22227                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22228                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22229                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22230                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22231                         return 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));
22232                 }
22233                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22234                 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));
22235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22236                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22237                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22238         }
22239         if (flags & NDR_OUT) {
22240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22241         }
22242         return NDR_ERR_SUCCESS;
22243 }
22244
22245 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22246 {
22247         ndr_print_struct(ndr, name, "spoolss_SetForm");
22248         ndr->depth++;
22249         if (flags & NDR_SET_VALUES) {
22250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22251         }
22252         if (flags & NDR_IN) {
22253                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22254                 ndr->depth++;
22255                 ndr_print_ptr(ndr, "handle", r->in.handle);
22256                 ndr->depth++;
22257                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22258                 ndr->depth--;
22259                 ndr_print_string(ndr, "form_name", r->in.form_name);
22260                 ndr_print_uint32(ndr, "level", r->in.level);
22261                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22262                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22263                 ndr->depth--;
22264         }
22265         if (flags & NDR_OUT) {
22266                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22267                 ndr->depth++;
22268                 ndr_print_WERROR(ndr, "result", r->out.result);
22269                 ndr->depth--;
22270         }
22271         ndr->depth--;
22272 }
22273
22274 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22275 {
22276         if (flags & NDR_IN) {
22277                 if (r->in.handle == NULL) {
22278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22279                 }
22280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22283                 if (r->in.buffer) {
22284                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22285                 }
22286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22287         }
22288         if (flags & NDR_OUT) {
22289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22290                 if (r->out.info) {
22291                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22292                 }
22293                 if (r->out.needed == NULL) {
22294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22295                 }
22296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22297                 if (r->out.count == NULL) {
22298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22299                 }
22300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22301                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22302         }
22303         return NDR_ERR_SUCCESS;
22304 }
22305
22306 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22307 {
22308         uint32_t _ptr_buffer;
22309         uint32_t _ptr_info;
22310         TALLOC_CTX *_mem_save_handle_0;
22311         TALLOC_CTX *_mem_save_buffer_0;
22312         TALLOC_CTX *_mem_save_info_0;
22313         TALLOC_CTX *_mem_save_needed_0;
22314         TALLOC_CTX *_mem_save_count_0;
22315         if (flags & NDR_IN) {
22316                 ZERO_STRUCT(r->out);
22317
22318                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22319                         NDR_PULL_ALLOC(ndr, r->in.handle);
22320                 }
22321                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22322                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22323                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22324                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22326                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22327                 if (_ptr_buffer) {
22328                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22329                 } else {
22330                         r->in.buffer = NULL;
22331                 }
22332                 if (r->in.buffer) {
22333                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22334                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22335                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22337                 }
22338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22339                 NDR_PULL_ALLOC(ndr, r->out.needed);
22340                 ZERO_STRUCTP(r->out.needed);
22341                 NDR_PULL_ALLOC(ndr, r->out.count);
22342                 ZERO_STRUCTP(r->out.count);
22343         }
22344         if (flags & NDR_OUT) {
22345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22346                 if (_ptr_info) {
22347                         NDR_PULL_ALLOC(ndr, r->out.info);
22348                 } else {
22349                         r->out.info = NULL;
22350                 }
22351                 if (r->out.info) {
22352                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22353                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22354                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22356                 }
22357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22358                         NDR_PULL_ALLOC(ndr, r->out.needed);
22359                 }
22360                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22365                         NDR_PULL_ALLOC(ndr, r->out.count);
22366                 }
22367                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22368                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22371                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22372         }
22373         return NDR_ERR_SUCCESS;
22374 }
22375
22376 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22377 {
22378         uint32_t cntr_info_0;
22379         if (flags & NDR_IN) {
22380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22382         }
22383         if (flags & NDR_OUT) {
22384                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22385                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22386                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22387                 }
22388                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22389                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22390                 }
22391         }
22392         return NDR_ERR_SUCCESS;
22393 }
22394
22395 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22396 {
22397         uint32_t cntr_info_0;
22398         TALLOC_CTX *_mem_save_info_0;
22399         if (flags & NDR_IN) {
22400                 ZERO_STRUCT(r->out);
22401
22402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22404         }
22405         if (flags & NDR_OUT) {
22406                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22407                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22408                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22409                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22410                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22411                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22412                 }
22413                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22414                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22415                 }
22416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22417         }
22418         return NDR_ERR_SUCCESS;
22419 }
22420
22421 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22422 {
22423         uint32_t cntr_info_2;
22424         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22425         ndr->depth++;
22426         if (flags & NDR_SET_VALUES) {
22427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22428         }
22429         if (flags & NDR_IN) {
22430                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22431                 ndr->depth++;
22432                 ndr_print_ptr(ndr, "handle", r->in.handle);
22433                 ndr->depth++;
22434                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22435                 ndr->depth--;
22436                 ndr_print_uint32(ndr, "level", r->in.level);
22437                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22438                 ndr->depth++;
22439                 if (r->in.buffer) {
22440                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22441                 }
22442                 ndr->depth--;
22443                 ndr_print_uint32(ndr, "offered", r->in.offered);
22444                 ndr->depth--;
22445         }
22446         if (flags & NDR_OUT) {
22447                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22448                 ndr->depth++;
22449                 ndr_print_ptr(ndr, "count", r->out.count);
22450                 ndr->depth++;
22451                 ndr_print_uint32(ndr, "count", *r->out.count);
22452                 ndr->depth--;
22453                 ndr_print_ptr(ndr, "info", r->out.info);
22454                 ndr->depth++;
22455                 ndr_print_ptr(ndr, "info", *r->out.info);
22456                 ndr->depth++;
22457                 if (*r->out.info) {
22458                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22459                         ndr->depth++;
22460                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22461                                 char *idx_2=NULL;
22462                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22463                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22464                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22465                                         free(idx_2);
22466                                 }
22467                         }
22468                         ndr->depth--;
22469                 }
22470                 ndr->depth--;
22471                 ndr->depth--;
22472                 ndr_print_ptr(ndr, "needed", r->out.needed);
22473                 ndr->depth++;
22474                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22475                 ndr->depth--;
22476                 ndr_print_WERROR(ndr, "result", r->out.result);
22477                 ndr->depth--;
22478         }
22479         ndr->depth--;
22480 }
22481
22482 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22483 {
22484         if (flags & NDR_IN) {
22485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22486                 if (r->in.servername) {
22487                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22488                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22490                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22491                 }
22492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22494                 if (r->in.buffer) {
22495                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22496                 }
22497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22498         }
22499         if (flags & NDR_OUT) {
22500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22501                 if (r->out.info) {
22502                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22503                 }
22504                 if (r->out.needed == NULL) {
22505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22506                 }
22507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22508                 if (r->out.count == NULL) {
22509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22510                 }
22511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22512                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22513         }
22514         return NDR_ERR_SUCCESS;
22515 }
22516
22517 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22518 {
22519         uint32_t _ptr_servername;
22520         uint32_t _ptr_buffer;
22521         uint32_t _ptr_info;
22522         TALLOC_CTX *_mem_save_servername_0;
22523         TALLOC_CTX *_mem_save_buffer_0;
22524         TALLOC_CTX *_mem_save_info_0;
22525         TALLOC_CTX *_mem_save_needed_0;
22526         TALLOC_CTX *_mem_save_count_0;
22527         if (flags & NDR_IN) {
22528                 ZERO_STRUCT(r->out);
22529
22530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22531                 if (_ptr_servername) {
22532                         NDR_PULL_ALLOC(ndr, r->in.servername);
22533                 } else {
22534                         r->in.servername = NULL;
22535                 }
22536                 if (r->in.servername) {
22537                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22538                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22541                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22542                                 return 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));
22543                         }
22544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22547                 }
22548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22550                 if (_ptr_buffer) {
22551                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22552                 } else {
22553                         r->in.buffer = NULL;
22554                 }
22555                 if (r->in.buffer) {
22556                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22557                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22558                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22560                 }
22561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22562                 NDR_PULL_ALLOC(ndr, r->out.needed);
22563                 ZERO_STRUCTP(r->out.needed);
22564                 NDR_PULL_ALLOC(ndr, r->out.count);
22565                 ZERO_STRUCTP(r->out.count);
22566         }
22567         if (flags & NDR_OUT) {
22568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22569                 if (_ptr_info) {
22570                         NDR_PULL_ALLOC(ndr, r->out.info);
22571                 } else {
22572                         r->out.info = NULL;
22573                 }
22574                 if (r->out.info) {
22575                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22576                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22577                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22579                 }
22580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22581                         NDR_PULL_ALLOC(ndr, r->out.needed);
22582                 }
22583                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22584                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22587                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22588                         NDR_PULL_ALLOC(ndr, r->out.count);
22589                 }
22590                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22591                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22593                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22595         }
22596         return NDR_ERR_SUCCESS;
22597 }
22598
22599 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22600 {
22601         uint32_t cntr_info_0;
22602         if (flags & NDR_IN) {
22603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22605         }
22606         if (flags & NDR_OUT) {
22607                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22608                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22609                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22610                 }
22611                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22612                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22613                 }
22614         }
22615         return NDR_ERR_SUCCESS;
22616 }
22617
22618 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22619 {
22620         uint32_t cntr_info_0;
22621         TALLOC_CTX *_mem_save_info_0;
22622         if (flags & NDR_IN) {
22623                 ZERO_STRUCT(r->out);
22624
22625                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22626                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22627         }
22628         if (flags & NDR_OUT) {
22629                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22630                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22631                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22632                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22633                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22634                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22635                 }
22636                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22637                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22638                 }
22639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22640         }
22641         return NDR_ERR_SUCCESS;
22642 }
22643
22644 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22645 {
22646         uint32_t cntr_info_2;
22647         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22648         ndr->depth++;
22649         if (flags & NDR_SET_VALUES) {
22650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22651         }
22652         if (flags & NDR_IN) {
22653                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22654                 ndr->depth++;
22655                 ndr_print_ptr(ndr, "servername", r->in.servername);
22656                 ndr->depth++;
22657                 if (r->in.servername) {
22658                         ndr_print_string(ndr, "servername", r->in.servername);
22659                 }
22660                 ndr->depth--;
22661                 ndr_print_uint32(ndr, "level", r->in.level);
22662                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22663                 ndr->depth++;
22664                 if (r->in.buffer) {
22665                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22666                 }
22667                 ndr->depth--;
22668                 ndr_print_uint32(ndr, "offered", r->in.offered);
22669                 ndr->depth--;
22670         }
22671         if (flags & NDR_OUT) {
22672                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22673                 ndr->depth++;
22674                 ndr_print_ptr(ndr, "count", r->out.count);
22675                 ndr->depth++;
22676                 ndr_print_uint32(ndr, "count", *r->out.count);
22677                 ndr->depth--;
22678                 ndr_print_ptr(ndr, "info", r->out.info);
22679                 ndr->depth++;
22680                 ndr_print_ptr(ndr, "info", *r->out.info);
22681                 ndr->depth++;
22682                 if (*r->out.info) {
22683                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22684                         ndr->depth++;
22685                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22686                                 char *idx_2=NULL;
22687                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22688                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22689                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22690                                         free(idx_2);
22691                                 }
22692                         }
22693                         ndr->depth--;
22694                 }
22695                 ndr->depth--;
22696                 ndr->depth--;
22697                 ndr_print_ptr(ndr, "needed", r->out.needed);
22698                 ndr->depth++;
22699                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22700                 ndr->depth--;
22701                 ndr_print_WERROR(ndr, "result", r->out.result);
22702                 ndr->depth--;
22703         }
22704         ndr->depth--;
22705 }
22706
22707 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22708 {
22709         if (flags & NDR_IN) {
22710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22711                 if (r->in.servername) {
22712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22716                 }
22717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22719                 if (r->in.buffer) {
22720                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22721                 }
22722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22723         }
22724         if (flags & NDR_OUT) {
22725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22726                 if (r->out.info) {
22727                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22728                 }
22729                 if (r->out.needed == NULL) {
22730                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22731                 }
22732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22733                 if (r->out.count == NULL) {
22734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22735                 }
22736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22737                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22738         }
22739         return NDR_ERR_SUCCESS;
22740 }
22741
22742 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22743 {
22744         uint32_t _ptr_servername;
22745         uint32_t _ptr_buffer;
22746         uint32_t _ptr_info;
22747         TALLOC_CTX *_mem_save_servername_0;
22748         TALLOC_CTX *_mem_save_buffer_0;
22749         TALLOC_CTX *_mem_save_info_0;
22750         TALLOC_CTX *_mem_save_needed_0;
22751         TALLOC_CTX *_mem_save_count_0;
22752         if (flags & NDR_IN) {
22753                 ZERO_STRUCT(r->out);
22754
22755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22756                 if (_ptr_servername) {
22757                         NDR_PULL_ALLOC(ndr, r->in.servername);
22758                 } else {
22759                         r->in.servername = NULL;
22760                 }
22761                 if (r->in.servername) {
22762                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22763                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22766                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22767                                 return 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));
22768                         }
22769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22772                 }
22773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22775                 if (_ptr_buffer) {
22776                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22777                 } else {
22778                         r->in.buffer = NULL;
22779                 }
22780                 if (r->in.buffer) {
22781                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22782                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22783                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22785                 }
22786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22787                 NDR_PULL_ALLOC(ndr, r->out.needed);
22788                 ZERO_STRUCTP(r->out.needed);
22789                 NDR_PULL_ALLOC(ndr, r->out.count);
22790                 ZERO_STRUCTP(r->out.count);
22791         }
22792         if (flags & NDR_OUT) {
22793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22794                 if (_ptr_info) {
22795                         NDR_PULL_ALLOC(ndr, r->out.info);
22796                 } else {
22797                         r->out.info = NULL;
22798                 }
22799                 if (r->out.info) {
22800                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22801                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22802                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22804                 }
22805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22806                         NDR_PULL_ALLOC(ndr, r->out.needed);
22807                 }
22808                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22809                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22813                         NDR_PULL_ALLOC(ndr, r->out.count);
22814                 }
22815                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22819                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22820         }
22821         return NDR_ERR_SUCCESS;
22822 }
22823
22824 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22825 {
22826         uint32_t cntr_info_0;
22827         if (flags & NDR_IN) {
22828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22830         }
22831         if (flags & NDR_OUT) {
22832                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22833                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22834                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22835                 }
22836                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22837                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22838                 }
22839         }
22840         return NDR_ERR_SUCCESS;
22841 }
22842
22843 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22844 {
22845         uint32_t cntr_info_0;
22846         TALLOC_CTX *_mem_save_info_0;
22847         if (flags & NDR_IN) {
22848                 ZERO_STRUCT(r->out);
22849
22850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22852         }
22853         if (flags & NDR_OUT) {
22854                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22855                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22856                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22857                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22858                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22859                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22860                 }
22861                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22862                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22863                 }
22864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22865         }
22866         return NDR_ERR_SUCCESS;
22867 }
22868
22869 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22870 {
22871         uint32_t cntr_info_2;
22872         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22873         ndr->depth++;
22874         if (flags & NDR_SET_VALUES) {
22875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22876         }
22877         if (flags & NDR_IN) {
22878                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22879                 ndr->depth++;
22880                 ndr_print_ptr(ndr, "servername", r->in.servername);
22881                 ndr->depth++;
22882                 if (r->in.servername) {
22883                         ndr_print_string(ndr, "servername", r->in.servername);
22884                 }
22885                 ndr->depth--;
22886                 ndr_print_uint32(ndr, "level", r->in.level);
22887                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22888                 ndr->depth++;
22889                 if (r->in.buffer) {
22890                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22891                 }
22892                 ndr->depth--;
22893                 ndr_print_uint32(ndr, "offered", r->in.offered);
22894                 ndr->depth--;
22895         }
22896         if (flags & NDR_OUT) {
22897                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22898                 ndr->depth++;
22899                 ndr_print_ptr(ndr, "count", r->out.count);
22900                 ndr->depth++;
22901                 ndr_print_uint32(ndr, "count", *r->out.count);
22902                 ndr->depth--;
22903                 ndr_print_ptr(ndr, "info", r->out.info);
22904                 ndr->depth++;
22905                 ndr_print_ptr(ndr, "info", *r->out.info);
22906                 ndr->depth++;
22907                 if (*r->out.info) {
22908                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22909                         ndr->depth++;
22910                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22911                                 char *idx_2=NULL;
22912                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22913                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22914                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22915                                         free(idx_2);
22916                                 }
22917                         }
22918                         ndr->depth--;
22919                 }
22920                 ndr->depth--;
22921                 ndr->depth--;
22922                 ndr_print_ptr(ndr, "needed", r->out.needed);
22923                 ndr->depth++;
22924                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22925                 ndr->depth--;
22926                 ndr_print_WERROR(ndr, "result", r->out.result);
22927                 ndr->depth--;
22928         }
22929         ndr->depth--;
22930 }
22931
22932 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22933 {
22934         if (flags & NDR_IN) {
22935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22936                 if (r->in.server_name) {
22937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22938                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22940                         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));
22941                 }
22942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22946                 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));
22947         }
22948         if (flags & NDR_OUT) {
22949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22950         }
22951         return NDR_ERR_SUCCESS;
22952 }
22953
22954 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
22955 {
22956         uint32_t _ptr_server_name;
22957         TALLOC_CTX *_mem_save_server_name_0;
22958         if (flags & NDR_IN) {
22959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
22960                 if (_ptr_server_name) {
22961                         NDR_PULL_ALLOC(ndr, r->in.server_name);
22962                 } else {
22963                         r->in.server_name = NULL;
22964                 }
22965                 if (r->in.server_name) {
22966                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
22967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
22968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22970                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22971                                 return 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));
22972                         }
22973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22974                         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));
22975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
22976                 }
22977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
22978                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
22979                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
22980                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
22981                         return 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));
22982                 }
22983                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
22984                 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));
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_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
22993 {
22994         ndr_print_struct(ndr, name, "spoolss_AddPort");
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_AddPort");
23001                 ndr->depth++;
23002                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23003                 ndr->depth++;
23004                 if (r->in.server_name) {
23005                         ndr_print_string(ndr, "server_name", r->in.server_name);
23006                 }
23007                 ndr->depth--;
23008                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23009                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23010                 ndr->depth--;
23011         }
23012         if (flags & NDR_OUT) {
23013                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23014                 ndr->depth++;
23015                 ndr_print_WERROR(ndr, "result", r->out.result);
23016                 ndr->depth--;
23017         }
23018         ndr->depth--;
23019 }
23020
23021 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23022 {
23023         if (flags & NDR_IN) {
23024         }
23025         if (flags & NDR_OUT) {
23026                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23027         }
23028         return NDR_ERR_SUCCESS;
23029 }
23030
23031 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23032 {
23033         if (flags & NDR_IN) {
23034         }
23035         if (flags & NDR_OUT) {
23036                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23037         }
23038         return NDR_ERR_SUCCESS;
23039 }
23040
23041 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23042 {
23043         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23044         ndr->depth++;
23045         if (flags & NDR_SET_VALUES) {
23046                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23047         }
23048         if (flags & NDR_IN) {
23049                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23050                 ndr->depth++;
23051                 ndr->depth--;
23052         }
23053         if (flags & NDR_OUT) {
23054                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23055                 ndr->depth++;
23056                 ndr_print_WERROR(ndr, "result", r->out.result);
23057                 ndr->depth--;
23058         }
23059         ndr->depth--;
23060 }
23061
23062 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23063 {
23064         if (flags & NDR_IN) {
23065         }
23066         if (flags & NDR_OUT) {
23067                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23068         }
23069         return NDR_ERR_SUCCESS;
23070 }
23071
23072 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23073 {
23074         if (flags & NDR_IN) {
23075         }
23076         if (flags & NDR_OUT) {
23077                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23078         }
23079         return NDR_ERR_SUCCESS;
23080 }
23081
23082 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23083 {
23084         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23085         ndr->depth++;
23086         if (flags & NDR_SET_VALUES) {
23087                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23088         }
23089         if (flags & NDR_IN) {
23090                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23091                 ndr->depth++;
23092                 ndr->depth--;
23093         }
23094         if (flags & NDR_OUT) {
23095                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23096                 ndr->depth++;
23097                 ndr_print_WERROR(ndr, "result", r->out.result);
23098                 ndr->depth--;
23099         }
23100         ndr->depth--;
23101 }
23102
23103 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23104 {
23105         if (flags & NDR_IN) {
23106         }
23107         if (flags & NDR_OUT) {
23108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23109         }
23110         return NDR_ERR_SUCCESS;
23111 }
23112
23113 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23114 {
23115         if (flags & NDR_IN) {
23116         }
23117         if (flags & NDR_OUT) {
23118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23119         }
23120         return NDR_ERR_SUCCESS;
23121 }
23122
23123 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23124 {
23125         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23126         ndr->depth++;
23127         if (flags & NDR_SET_VALUES) {
23128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23129         }
23130         if (flags & NDR_IN) {
23131                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23132                 ndr->depth++;
23133                 ndr->depth--;
23134         }
23135         if (flags & NDR_OUT) {
23136                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23137                 ndr->depth++;
23138                 ndr_print_WERROR(ndr, "result", r->out.result);
23139                 ndr->depth--;
23140         }
23141         ndr->depth--;
23142 }
23143
23144 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23145 {
23146         if (flags & NDR_IN) {
23147         }
23148         if (flags & NDR_OUT) {
23149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23150         }
23151         return NDR_ERR_SUCCESS;
23152 }
23153
23154 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23155 {
23156         if (flags & NDR_IN) {
23157         }
23158         if (flags & NDR_OUT) {
23159                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23160         }
23161         return NDR_ERR_SUCCESS;
23162 }
23163
23164 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23165 {
23166         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23167         ndr->depth++;
23168         if (flags & NDR_SET_VALUES) {
23169                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23170         }
23171         if (flags & NDR_IN) {
23172                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23173                 ndr->depth++;
23174                 ndr->depth--;
23175         }
23176         if (flags & NDR_OUT) {
23177                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23178                 ndr->depth++;
23179                 ndr_print_WERROR(ndr, "result", r->out.result);
23180                 ndr->depth--;
23181         }
23182         ndr->depth--;
23183 }
23184
23185 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23186 {
23187         if (flags & NDR_IN) {
23188         }
23189         if (flags & NDR_OUT) {
23190                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23191         }
23192         return NDR_ERR_SUCCESS;
23193 }
23194
23195 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23196 {
23197         if (flags & NDR_IN) {
23198         }
23199         if (flags & NDR_OUT) {
23200                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23201         }
23202         return NDR_ERR_SUCCESS;
23203 }
23204
23205 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23206 {
23207         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23208         ndr->depth++;
23209         if (flags & NDR_SET_VALUES) {
23210                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23211         }
23212         if (flags & NDR_IN) {
23213                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23214                 ndr->depth++;
23215                 ndr->depth--;
23216         }
23217         if (flags & NDR_OUT) {
23218                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23219                 ndr->depth++;
23220                 ndr_print_WERROR(ndr, "result", r->out.result);
23221                 ndr->depth--;
23222         }
23223         ndr->depth--;
23224 }
23225
23226 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23227 {
23228         if (flags & NDR_IN) {
23229         }
23230         if (flags & NDR_OUT) {
23231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23232         }
23233         return NDR_ERR_SUCCESS;
23234 }
23235
23236 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23237 {
23238         if (flags & NDR_IN) {
23239         }
23240         if (flags & NDR_OUT) {
23241                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23242         }
23243         return NDR_ERR_SUCCESS;
23244 }
23245
23246 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23247 {
23248         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23249         ndr->depth++;
23250         if (flags & NDR_SET_VALUES) {
23251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23252         }
23253         if (flags & NDR_IN) {
23254                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23255                 ndr->depth++;
23256                 ndr->depth--;
23257         }
23258         if (flags & NDR_OUT) {
23259                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23260                 ndr->depth++;
23261                 ndr_print_WERROR(ndr, "result", r->out.result);
23262                 ndr->depth--;
23263         }
23264         ndr->depth--;
23265 }
23266
23267 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23268 {
23269         if (flags & NDR_IN) {
23270         }
23271         if (flags & NDR_OUT) {
23272                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23273         }
23274         return NDR_ERR_SUCCESS;
23275 }
23276
23277 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23278 {
23279         if (flags & NDR_IN) {
23280         }
23281         if (flags & NDR_OUT) {
23282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23283         }
23284         return NDR_ERR_SUCCESS;
23285 }
23286
23287 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23288 {
23289         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23290         ndr->depth++;
23291         if (flags & NDR_SET_VALUES) {
23292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23293         }
23294         if (flags & NDR_IN) {
23295                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23296                 ndr->depth++;
23297                 ndr->depth--;
23298         }
23299         if (flags & NDR_OUT) {
23300                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23301                 ndr->depth++;
23302                 ndr_print_WERROR(ndr, "result", r->out.result);
23303                 ndr->depth--;
23304         }
23305         ndr->depth--;
23306 }
23307
23308 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23309 {
23310         if (flags & NDR_IN) {
23311         }
23312         if (flags & NDR_OUT) {
23313                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23314         }
23315         return NDR_ERR_SUCCESS;
23316 }
23317
23318 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23319 {
23320         if (flags & NDR_IN) {
23321         }
23322         if (flags & NDR_OUT) {
23323                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23324         }
23325         return NDR_ERR_SUCCESS;
23326 }
23327
23328 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23329 {
23330         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23331         ndr->depth++;
23332         if (flags & NDR_SET_VALUES) {
23333                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23334         }
23335         if (flags & NDR_IN) {
23336                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23337                 ndr->depth++;
23338                 ndr->depth--;
23339         }
23340         if (flags & NDR_OUT) {
23341                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23342                 ndr->depth++;
23343                 ndr_print_WERROR(ndr, "result", r->out.result);
23344                 ndr->depth--;
23345         }
23346         ndr->depth--;
23347 }
23348
23349 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23350 {
23351         if (flags & NDR_IN) {
23352         }
23353         if (flags & NDR_OUT) {
23354                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23355         }
23356         return NDR_ERR_SUCCESS;
23357 }
23358
23359 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23360 {
23361         if (flags & NDR_IN) {
23362         }
23363         if (flags & NDR_OUT) {
23364                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23365         }
23366         return NDR_ERR_SUCCESS;
23367 }
23368
23369 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23370 {
23371         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23372         ndr->depth++;
23373         if (flags & NDR_SET_VALUES) {
23374                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23375         }
23376         if (flags & NDR_IN) {
23377                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23378                 ndr->depth++;
23379                 ndr->depth--;
23380         }
23381         if (flags & NDR_OUT) {
23382                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23383                 ndr->depth++;
23384                 ndr_print_WERROR(ndr, "result", r->out.result);
23385                 ndr->depth--;
23386         }
23387         ndr->depth--;
23388 }
23389
23390 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23391 {
23392         if (flags & NDR_IN) {
23393         }
23394         if (flags & NDR_OUT) {
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_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23401 {
23402         if (flags & NDR_IN) {
23403         }
23404         if (flags & NDR_OUT) {
23405                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23406         }
23407         return NDR_ERR_SUCCESS;
23408 }
23409
23410 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23411 {
23412         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23413         ndr->depth++;
23414         if (flags & NDR_SET_VALUES) {
23415                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23416         }
23417         if (flags & NDR_IN) {
23418                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23419                 ndr->depth++;
23420                 ndr->depth--;
23421         }
23422         if (flags & NDR_OUT) {
23423                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23424                 ndr->depth++;
23425                 ndr_print_WERROR(ndr, "result", r->out.result);
23426                 ndr->depth--;
23427         }
23428         ndr->depth--;
23429 }
23430
23431 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23432 {
23433         if (flags & NDR_IN) {
23434         }
23435         if (flags & NDR_OUT) {
23436                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23437         }
23438         return NDR_ERR_SUCCESS;
23439 }
23440
23441 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23442 {
23443         if (flags & NDR_IN) {
23444         }
23445         if (flags & NDR_OUT) {
23446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23447         }
23448         return NDR_ERR_SUCCESS;
23449 }
23450
23451 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23452 {
23453         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23454         ndr->depth++;
23455         if (flags & NDR_SET_VALUES) {
23456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23457         }
23458         if (flags & NDR_IN) {
23459                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23460                 ndr->depth++;
23461                 ndr->depth--;
23462         }
23463         if (flags & NDR_OUT) {
23464                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23465                 ndr->depth++;
23466                 ndr_print_WERROR(ndr, "result", r->out.result);
23467                 ndr->depth--;
23468         }
23469         ndr->depth--;
23470 }
23471
23472 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23473 {
23474         if (flags & NDR_IN) {
23475         }
23476         if (flags & NDR_OUT) {
23477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23478         }
23479         return NDR_ERR_SUCCESS;
23480 }
23481
23482 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23483 {
23484         if (flags & NDR_IN) {
23485         }
23486         if (flags & NDR_OUT) {
23487                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23488         }
23489         return NDR_ERR_SUCCESS;
23490 }
23491
23492 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23493 {
23494         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23495         ndr->depth++;
23496         if (flags & NDR_SET_VALUES) {
23497                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23498         }
23499         if (flags & NDR_IN) {
23500                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23501                 ndr->depth++;
23502                 ndr->depth--;
23503         }
23504         if (flags & NDR_OUT) {
23505                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23506                 ndr->depth++;
23507                 ndr_print_WERROR(ndr, "result", r->out.result);
23508                 ndr->depth--;
23509         }
23510         ndr->depth--;
23511 }
23512
23513 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23514 {
23515         if (flags & NDR_IN) {
23516         }
23517         if (flags & NDR_OUT) {
23518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23519         }
23520         return NDR_ERR_SUCCESS;
23521 }
23522
23523 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23524 {
23525         if (flags & NDR_IN) {
23526         }
23527         if (flags & NDR_OUT) {
23528                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23529         }
23530         return NDR_ERR_SUCCESS;
23531 }
23532
23533 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23534 {
23535         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23536         ndr->depth++;
23537         if (flags & NDR_SET_VALUES) {
23538                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23539         }
23540         if (flags & NDR_IN) {
23541                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23542                 ndr->depth++;
23543                 ndr->depth--;
23544         }
23545         if (flags & NDR_OUT) {
23546                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23547                 ndr->depth++;
23548                 ndr_print_WERROR(ndr, "result", r->out.result);
23549                 ndr->depth--;
23550         }
23551         ndr->depth--;
23552 }
23553
23554 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23555 {
23556         if (flags & NDR_IN) {
23557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23558                 if (r->in.servername) {
23559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23562                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23563                 }
23564                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23565                 if (r->in.print_processor_name) {
23566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23567                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23568                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23569                         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));
23570                 }
23571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23573                 if (r->in.buffer) {
23574                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23575                 }
23576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23577         }
23578         if (flags & NDR_OUT) {
23579                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23580                 if (r->out.info) {
23581                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23582                 }
23583                 if (r->out.needed == NULL) {
23584                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23585                 }
23586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23587                 if (r->out.count == NULL) {
23588                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23589                 }
23590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23591                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23592         }
23593         return NDR_ERR_SUCCESS;
23594 }
23595
23596 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23597 {
23598         uint32_t _ptr_servername;
23599         uint32_t _ptr_print_processor_name;
23600         uint32_t _ptr_buffer;
23601         uint32_t _ptr_info;
23602         TALLOC_CTX *_mem_save_servername_0;
23603         TALLOC_CTX *_mem_save_print_processor_name_0;
23604         TALLOC_CTX *_mem_save_buffer_0;
23605         TALLOC_CTX *_mem_save_info_0;
23606         TALLOC_CTX *_mem_save_needed_0;
23607         TALLOC_CTX *_mem_save_count_0;
23608         if (flags & NDR_IN) {
23609                 ZERO_STRUCT(r->out);
23610
23611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23612                 if (_ptr_servername) {
23613                         NDR_PULL_ALLOC(ndr, r->in.servername);
23614                 } else {
23615                         r->in.servername = NULL;
23616                 }
23617                 if (r->in.servername) {
23618                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23619                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23622                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23623                                 return 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));
23624                         }
23625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23628                 }
23629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23630                 if (_ptr_print_processor_name) {
23631                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23632                 } else {
23633                         r->in.print_processor_name = NULL;
23634                 }
23635                 if (r->in.print_processor_name) {
23636                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23639                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23640                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23641                                 return 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));
23642                         }
23643                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23644                         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));
23645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23646                 }
23647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23648                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23649                 if (_ptr_buffer) {
23650                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23651                 } else {
23652                         r->in.buffer = NULL;
23653                 }
23654                 if (r->in.buffer) {
23655                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23656                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23657                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23659                 }
23660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23661                 NDR_PULL_ALLOC(ndr, r->out.needed);
23662                 ZERO_STRUCTP(r->out.needed);
23663                 NDR_PULL_ALLOC(ndr, r->out.count);
23664                 ZERO_STRUCTP(r->out.count);
23665         }
23666         if (flags & NDR_OUT) {
23667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23668                 if (_ptr_info) {
23669                         NDR_PULL_ALLOC(ndr, r->out.info);
23670                 } else {
23671                         r->out.info = NULL;
23672                 }
23673                 if (r->out.info) {
23674                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23675                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23676                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23678                 }
23679                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23680                         NDR_PULL_ALLOC(ndr, r->out.needed);
23681                 }
23682                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23683                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23685                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23687                         NDR_PULL_ALLOC(ndr, r->out.count);
23688                 }
23689                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23690                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23691                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23692                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23693                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23694         }
23695         return NDR_ERR_SUCCESS;
23696 }
23697
23698 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23699 {
23700         uint32_t cntr_info_0;
23701         if (flags & NDR_IN) {
23702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23704         }
23705         if (flags & NDR_OUT) {
23706                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23707                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23708                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23709                 }
23710                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23711                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23712                 }
23713         }
23714         return NDR_ERR_SUCCESS;
23715 }
23716
23717 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23718 {
23719         uint32_t cntr_info_0;
23720         TALLOC_CTX *_mem_save_info_0;
23721         if (flags & NDR_IN) {
23722                 ZERO_STRUCT(r->out);
23723
23724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23726         }
23727         if (flags & NDR_OUT) {
23728                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23729                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23731                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23732                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23733                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23734                 }
23735                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23736                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23737                 }
23738                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23739         }
23740         return NDR_ERR_SUCCESS;
23741 }
23742
23743 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23744 {
23745         uint32_t cntr_info_2;
23746         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23747         ndr->depth++;
23748         if (flags & NDR_SET_VALUES) {
23749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23750         }
23751         if (flags & NDR_IN) {
23752                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23753                 ndr->depth++;
23754                 ndr_print_ptr(ndr, "servername", r->in.servername);
23755                 ndr->depth++;
23756                 if (r->in.servername) {
23757                         ndr_print_string(ndr, "servername", r->in.servername);
23758                 }
23759                 ndr->depth--;
23760                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23761                 ndr->depth++;
23762                 if (r->in.print_processor_name) {
23763                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23764                 }
23765                 ndr->depth--;
23766                 ndr_print_uint32(ndr, "level", r->in.level);
23767                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23768                 ndr->depth++;
23769                 if (r->in.buffer) {
23770                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23771                 }
23772                 ndr->depth--;
23773                 ndr_print_uint32(ndr, "offered", r->in.offered);
23774                 ndr->depth--;
23775         }
23776         if (flags & NDR_OUT) {
23777                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23778                 ndr->depth++;
23779                 ndr_print_ptr(ndr, "count", r->out.count);
23780                 ndr->depth++;
23781                 ndr_print_uint32(ndr, "count", *r->out.count);
23782                 ndr->depth--;
23783                 ndr_print_ptr(ndr, "info", r->out.info);
23784                 ndr->depth++;
23785                 ndr_print_ptr(ndr, "info", *r->out.info);
23786                 ndr->depth++;
23787                 if (*r->out.info) {
23788                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23789                         ndr->depth++;
23790                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23791                                 char *idx_2=NULL;
23792                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23793                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23794                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23795                                         free(idx_2);
23796                                 }
23797                         }
23798                         ndr->depth--;
23799                 }
23800                 ndr->depth--;
23801                 ndr->depth--;
23802                 ndr_print_ptr(ndr, "needed", r->out.needed);
23803                 ndr->depth++;
23804                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23805                 ndr->depth--;
23806                 ndr_print_WERROR(ndr, "result", r->out.result);
23807                 ndr->depth--;
23808         }
23809         ndr->depth--;
23810 }
23811
23812 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23813 {
23814         if (flags & NDR_IN) {
23815                 if (r->in.handle == NULL) {
23816                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23817                 }
23818                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23819                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23820                 if (r->in.data_type) {
23821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23824                         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));
23825                 }
23826                 if (r->in.devmode_ctr == NULL) {
23827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23828                 }
23829                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23830         }
23831         if (flags & NDR_OUT) {
23832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23833         }
23834         return NDR_ERR_SUCCESS;
23835 }
23836
23837 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23838 {
23839         uint32_t _ptr_data_type;
23840         TALLOC_CTX *_mem_save_handle_0;
23841         TALLOC_CTX *_mem_save_data_type_0;
23842         TALLOC_CTX *_mem_save_devmode_ctr_0;
23843         if (flags & NDR_IN) {
23844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23845                         NDR_PULL_ALLOC(ndr, r->in.handle);
23846                 }
23847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23852                 if (_ptr_data_type) {
23853                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23854                 } else {
23855                         r->in.data_type = NULL;
23856                 }
23857                 if (r->in.data_type) {
23858                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23859                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23860                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23861                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23862                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23863                                 return 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));
23864                         }
23865                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23866                         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));
23867                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23868                 }
23869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23870                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23871                 }
23872                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23873                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23874                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23876         }
23877         if (flags & NDR_OUT) {
23878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23879         }
23880         return NDR_ERR_SUCCESS;
23881 }
23882
23883 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23884 {
23885         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23886         ndr->depth++;
23887         if (flags & NDR_SET_VALUES) {
23888                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23889         }
23890         if (flags & NDR_IN) {
23891                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23892                 ndr->depth++;
23893                 ndr_print_ptr(ndr, "handle", r->in.handle);
23894                 ndr->depth++;
23895                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23896                 ndr->depth--;
23897                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23898                 ndr->depth++;
23899                 if (r->in.data_type) {
23900                         ndr_print_string(ndr, "data_type", r->in.data_type);
23901                 }
23902                 ndr->depth--;
23903                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23904                 ndr->depth++;
23905                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23906                 ndr->depth--;
23907                 ndr->depth--;
23908         }
23909         if (flags & NDR_OUT) {
23910                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23911                 ndr->depth++;
23912                 ndr_print_WERROR(ndr, "result", r->out.result);
23913                 ndr->depth--;
23914         }
23915         ndr->depth--;
23916 }
23917
23918 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23919 {
23920         if (flags & NDR_IN) {
23921                 if (r->in.handle == NULL) {
23922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23923                 }
23924                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23926                 if (r->in.architecture) {
23927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23931                 }
23932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23934                 if (r->in.buffer) {
23935                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23936                 }
23937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23940         }
23941         if (flags & NDR_OUT) {
23942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23943                 if (r->out.info) {
23944                         {
23945                                 struct ndr_push *_ndr_info;
23946                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23947                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23948                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23949                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23950                         }
23951                 }
23952                 if (r->out.needed == NULL) {
23953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23954                 }
23955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23956                 if (r->out.server_major_version == NULL) {
23957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23958                 }
23959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
23960                 if (r->out.server_minor_version == NULL) {
23961                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23962                 }
23963                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
23964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23965         }
23966         return NDR_ERR_SUCCESS;
23967 }
23968
23969 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
23970 {
23971         uint32_t _ptr_architecture;
23972         uint32_t _ptr_buffer;
23973         uint32_t _ptr_info;
23974         TALLOC_CTX *_mem_save_handle_0;
23975         TALLOC_CTX *_mem_save_architecture_0;
23976         TALLOC_CTX *_mem_save_buffer_0;
23977         TALLOC_CTX *_mem_save_info_0;
23978         TALLOC_CTX *_mem_save_needed_0;
23979         TALLOC_CTX *_mem_save_server_major_version_0;
23980         TALLOC_CTX *_mem_save_server_minor_version_0;
23981         if (flags & NDR_IN) {
23982                 ZERO_STRUCT(r->out);
23983
23984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23985                         NDR_PULL_ALLOC(ndr, r->in.handle);
23986                 }
23987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
23992                 if (_ptr_architecture) {
23993                         NDR_PULL_ALLOC(ndr, r->in.architecture);
23994                 } else {
23995                         r->in.architecture = NULL;
23996                 }
23997                 if (r->in.architecture) {
23998                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
23999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24002                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24003                                 return 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));
24004                         }
24005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24008                 }
24009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24011                 if (_ptr_buffer) {
24012                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24013                 } else {
24014                         r->in.buffer = NULL;
24015                 }
24016                 if (r->in.buffer) {
24017                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24018                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24019                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24021                 }
24022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24025                 NDR_PULL_ALLOC(ndr, r->out.needed);
24026                 ZERO_STRUCTP(r->out.needed);
24027                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24028                 ZERO_STRUCTP(r->out.server_major_version);
24029                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24030                 ZERO_STRUCTP(r->out.server_minor_version);
24031         }
24032         if (flags & NDR_OUT) {
24033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24034                 if (_ptr_info) {
24035                         NDR_PULL_ALLOC(ndr, r->out.info);
24036                 } else {
24037                         r->out.info = NULL;
24038                 }
24039                 if (r->out.info) {
24040                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24041                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24042                         {
24043                                 struct ndr_pull *_ndr_info;
24044                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24045                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24046                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24047                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24048                         }
24049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24050                 }
24051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24052                         NDR_PULL_ALLOC(ndr, r->out.needed);
24053                 }
24054                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24055                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24058                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24059                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24060                 }
24061                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24062                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24063                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24064                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24066                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24067                 }
24068                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24073         }
24074         return NDR_ERR_SUCCESS;
24075 }
24076
24077 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24078 {
24079         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24080         ndr->depth++;
24081         if (flags & NDR_SET_VALUES) {
24082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24083         }
24084         if (flags & NDR_IN) {
24085                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24086                 ndr->depth++;
24087                 ndr_print_ptr(ndr, "handle", r->in.handle);
24088                 ndr->depth++;
24089                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24090                 ndr->depth--;
24091                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24092                 ndr->depth++;
24093                 if (r->in.architecture) {
24094                         ndr_print_string(ndr, "architecture", r->in.architecture);
24095                 }
24096                 ndr->depth--;
24097                 ndr_print_uint32(ndr, "level", r->in.level);
24098                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24099                 ndr->depth++;
24100                 if (r->in.buffer) {
24101                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24102                 }
24103                 ndr->depth--;
24104                 ndr_print_uint32(ndr, "offered", r->in.offered);
24105                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24106                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24107                 ndr->depth--;
24108         }
24109         if (flags & NDR_OUT) {
24110                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24111                 ndr->depth++;
24112                 ndr_print_ptr(ndr, "info", r->out.info);
24113                 ndr->depth++;
24114                 if (r->out.info) {
24115                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24116                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24117                 }
24118                 ndr->depth--;
24119                 ndr_print_ptr(ndr, "needed", r->out.needed);
24120                 ndr->depth++;
24121                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24122                 ndr->depth--;
24123                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24124                 ndr->depth++;
24125                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24126                 ndr->depth--;
24127                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24128                 ndr->depth++;
24129                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24130                 ndr->depth--;
24131                 ndr_print_WERROR(ndr, "result", r->out.result);
24132                 ndr->depth--;
24133         }
24134         ndr->depth--;
24135 }
24136
24137 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24138 {
24139         if (flags & NDR_IN) {
24140         }
24141         if (flags & NDR_OUT) {
24142                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24143         }
24144         return NDR_ERR_SUCCESS;
24145 }
24146
24147 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24148 {
24149         if (flags & NDR_IN) {
24150         }
24151         if (flags & NDR_OUT) {
24152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24153         }
24154         return NDR_ERR_SUCCESS;
24155 }
24156
24157 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24158 {
24159         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24160         ndr->depth++;
24161         if (flags & NDR_SET_VALUES) {
24162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24163         }
24164         if (flags & NDR_IN) {
24165                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24166                 ndr->depth++;
24167                 ndr->depth--;
24168         }
24169         if (flags & NDR_OUT) {
24170                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24171                 ndr->depth++;
24172                 ndr_print_WERROR(ndr, "result", r->out.result);
24173                 ndr->depth--;
24174         }
24175         ndr->depth--;
24176 }
24177
24178 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24179 {
24180         if (flags & NDR_IN) {
24181         }
24182         if (flags & NDR_OUT) {
24183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24184         }
24185         return NDR_ERR_SUCCESS;
24186 }
24187
24188 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24189 {
24190         if (flags & NDR_IN) {
24191         }
24192         if (flags & NDR_OUT) {
24193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24194         }
24195         return NDR_ERR_SUCCESS;
24196 }
24197
24198 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24199 {
24200         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24201         ndr->depth++;
24202         if (flags & NDR_SET_VALUES) {
24203                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24204         }
24205         if (flags & NDR_IN) {
24206                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24207                 ndr->depth++;
24208                 ndr->depth--;
24209         }
24210         if (flags & NDR_OUT) {
24211                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24212                 ndr->depth++;
24213                 ndr_print_WERROR(ndr, "result", r->out.result);
24214                 ndr->depth--;
24215         }
24216         ndr->depth--;
24217 }
24218
24219 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24220 {
24221         if (flags & NDR_IN) {
24222                 if (r->in.handle == NULL) {
24223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24224                 }
24225                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24226         }
24227         if (flags & NDR_OUT) {
24228                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24229         }
24230         return NDR_ERR_SUCCESS;
24231 }
24232
24233 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24234 {
24235         TALLOC_CTX *_mem_save_handle_0;
24236         if (flags & NDR_IN) {
24237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24238                         NDR_PULL_ALLOC(ndr, r->in.handle);
24239                 }
24240                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24241                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24242                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24244         }
24245         if (flags & NDR_OUT) {
24246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24247         }
24248         return NDR_ERR_SUCCESS;
24249 }
24250
24251 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24252 {
24253         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24254         ndr->depth++;
24255         if (flags & NDR_SET_VALUES) {
24256                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24257         }
24258         if (flags & NDR_IN) {
24259                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24260                 ndr->depth++;
24261                 ndr_print_ptr(ndr, "handle", r->in.handle);
24262                 ndr->depth++;
24263                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24264                 ndr->depth--;
24265                 ndr->depth--;
24266         }
24267         if (flags & NDR_OUT) {
24268                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24269                 ndr->depth++;
24270                 ndr_print_WERROR(ndr, "result", r->out.result);
24271                 ndr->depth--;
24272         }
24273         ndr->depth--;
24274 }
24275
24276 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24277 {
24278         if (flags & NDR_IN) {
24279         }
24280         if (flags & NDR_OUT) {
24281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24282         }
24283         return NDR_ERR_SUCCESS;
24284 }
24285
24286 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24287 {
24288         if (flags & NDR_IN) {
24289         }
24290         if (flags & NDR_OUT) {
24291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24292         }
24293         return NDR_ERR_SUCCESS;
24294 }
24295
24296 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24297 {
24298         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24299         ndr->depth++;
24300         if (flags & NDR_SET_VALUES) {
24301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24302         }
24303         if (flags & NDR_IN) {
24304                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24305                 ndr->depth++;
24306                 ndr->depth--;
24307         }
24308         if (flags & NDR_OUT) {
24309                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24310                 ndr->depth++;
24311                 ndr_print_WERROR(ndr, "result", r->out.result);
24312                 ndr->depth--;
24313         }
24314         ndr->depth--;
24315 }
24316
24317 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24318 {
24319         if (flags & NDR_IN) {
24320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24323                 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));
24324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24325                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24328                 if (r->in.buffer) {
24329                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24330                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24331                 }
24332         }
24333         if (flags & NDR_OUT) {
24334                 if (r->out.handle == NULL) {
24335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24336                 }
24337                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24338                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24339         }
24340         return NDR_ERR_SUCCESS;
24341 }
24342
24343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24344 {
24345         uint32_t _ptr_buffer;
24346         TALLOC_CTX *_mem_save_buffer_0;
24347         TALLOC_CTX *_mem_save_handle_0;
24348         if (flags & NDR_IN) {
24349                 ZERO_STRUCT(r->out);
24350
24351                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24352                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24353                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24354                         return 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));
24355                 }
24356                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24357                 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));
24358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24359                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24361                 if (r->in.bufsize > 512) {
24362                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24363                 }
24364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24365                 if (_ptr_buffer) {
24366                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24367                 } else {
24368                         r->in.buffer = NULL;
24369                 }
24370                 if (r->in.buffer) {
24371                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24372                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24373                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24374                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24375                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24377                 }
24378                 NDR_PULL_ALLOC(ndr, r->out.handle);
24379                 ZERO_STRUCTP(r->out.handle);
24380                 if (r->in.buffer) {
24381                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24382                 }
24383         }
24384         if (flags & NDR_OUT) {
24385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24386                         NDR_PULL_ALLOC(ndr, r->out.handle);
24387                 }
24388                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24393         }
24394         return NDR_ERR_SUCCESS;
24395 }
24396
24397 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24398 {
24399         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24400         ndr->depth++;
24401         if (flags & NDR_SET_VALUES) {
24402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24403         }
24404         if (flags & NDR_IN) {
24405                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24406                 ndr->depth++;
24407                 ndr_print_string(ndr, "server_name", r->in.server_name);
24408                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24409                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24410                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24411                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24412                 ndr->depth++;
24413                 if (r->in.buffer) {
24414                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24415                 }
24416                 ndr->depth--;
24417                 ndr->depth--;
24418         }
24419         if (flags & NDR_OUT) {
24420                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24421                 ndr->depth++;
24422                 ndr_print_ptr(ndr, "handle", r->out.handle);
24423                 ndr->depth++;
24424                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24425                 ndr->depth--;
24426                 ndr_print_WERROR(ndr, "result", r->out.result);
24427                 ndr->depth--;
24428         }
24429         ndr->depth--;
24430 }
24431
24432 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24433 {
24434         if (flags & NDR_IN) {
24435                 if (r->in.handle == NULL) {
24436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24437                 }
24438                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24439                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24442                 if (r->in.buffer) {
24443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24444                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24445                 }
24446         }
24447         if (flags & NDR_OUT) {
24448                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24449         }
24450         return NDR_ERR_SUCCESS;
24451 }
24452
24453 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24454 {
24455         uint32_t _ptr_buffer;
24456         TALLOC_CTX *_mem_save_handle_0;
24457         TALLOC_CTX *_mem_save_buffer_0;
24458         if (flags & NDR_IN) {
24459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24460                         NDR_PULL_ALLOC(ndr, r->in.handle);
24461                 }
24462                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24464                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24466                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24468                 if (r->in.bufsize > 512) {
24469                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24470                 }
24471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24472                 if (_ptr_buffer) {
24473                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24474                 } else {
24475                         r->in.buffer = NULL;
24476                 }
24477                 if (r->in.buffer) {
24478                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24479                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24480                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24481                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24482                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24483                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24484                 }
24485                 if (r->in.buffer) {
24486                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24487                 }
24488         }
24489         if (flags & NDR_OUT) {
24490                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24491         }
24492         return NDR_ERR_SUCCESS;
24493 }
24494
24495 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24496 {
24497         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24498         ndr->depth++;
24499         if (flags & NDR_SET_VALUES) {
24500                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24501         }
24502         if (flags & NDR_IN) {
24503                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24504                 ndr->depth++;
24505                 ndr_print_ptr(ndr, "handle", r->in.handle);
24506                 ndr->depth++;
24507                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24508                 ndr->depth--;
24509                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24510                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24511                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24512                 ndr->depth++;
24513                 if (r->in.buffer) {
24514                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24515                 }
24516                 ndr->depth--;
24517                 ndr->depth--;
24518         }
24519         if (flags & NDR_OUT) {
24520                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24521                 ndr->depth++;
24522                 ndr_print_WERROR(ndr, "result", r->out.result);
24523                 ndr->depth--;
24524         }
24525         ndr->depth--;
24526 }
24527
24528 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24529 {
24530         if (flags & NDR_IN) {
24531                 if (r->in.handle == NULL) {
24532                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24533                 }
24534                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24535         }
24536         if (flags & NDR_OUT) {
24537                 if (r->out.handle == NULL) {
24538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24539                 }
24540                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24541                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24542         }
24543         return NDR_ERR_SUCCESS;
24544 }
24545
24546 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24547 {
24548         TALLOC_CTX *_mem_save_handle_0;
24549         if (flags & NDR_IN) {
24550                 ZERO_STRUCT(r->out);
24551
24552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24553                         NDR_PULL_ALLOC(ndr, r->in.handle);
24554                 }
24555                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24556                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24557                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24559                 NDR_PULL_ALLOC(ndr, r->out.handle);
24560                 *r->out.handle = *r->in.handle;
24561         }
24562         if (flags & NDR_OUT) {
24563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24564                         NDR_PULL_ALLOC(ndr, r->out.handle);
24565                 }
24566                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24568                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24570                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24571         }
24572         return NDR_ERR_SUCCESS;
24573 }
24574
24575 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24576 {
24577         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24578         ndr->depth++;
24579         if (flags & NDR_SET_VALUES) {
24580                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24581         }
24582         if (flags & NDR_IN) {
24583                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24584                 ndr->depth++;
24585                 ndr_print_ptr(ndr, "handle", r->in.handle);
24586                 ndr->depth++;
24587                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24588                 ndr->depth--;
24589                 ndr->depth--;
24590         }
24591         if (flags & NDR_OUT) {
24592                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24593                 ndr->depth++;
24594                 ndr_print_ptr(ndr, "handle", r->out.handle);
24595                 ndr->depth++;
24596                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24597                 ndr->depth--;
24598                 ndr_print_WERROR(ndr, "result", r->out.result);
24599                 ndr->depth--;
24600         }
24601         ndr->depth--;
24602 }
24603
24604 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24605 {
24606         if (flags & NDR_IN) {
24607         }
24608         if (flags & NDR_OUT) {
24609                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24610         }
24611         return NDR_ERR_SUCCESS;
24612 }
24613
24614 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24615 {
24616         if (flags & NDR_IN) {
24617         }
24618         if (flags & NDR_OUT) {
24619                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24620         }
24621         return NDR_ERR_SUCCESS;
24622 }
24623
24624 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24625 {
24626         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24627         ndr->depth++;
24628         if (flags & NDR_SET_VALUES) {
24629                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24630         }
24631         if (flags & NDR_IN) {
24632                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24633                 ndr->depth++;
24634                 ndr->depth--;
24635         }
24636         if (flags & NDR_OUT) {
24637                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24638                 ndr->depth++;
24639                 ndr_print_WERROR(ndr, "result", r->out.result);
24640                 ndr->depth--;
24641         }
24642         ndr->depth--;
24643 }
24644
24645 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24646 {
24647         if (flags & NDR_IN) {
24648         }
24649         if (flags & NDR_OUT) {
24650                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24651         }
24652         return NDR_ERR_SUCCESS;
24653 }
24654
24655 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24656 {
24657         if (flags & NDR_IN) {
24658         }
24659         if (flags & NDR_OUT) {
24660                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24661         }
24662         return NDR_ERR_SUCCESS;
24663 }
24664
24665 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24666 {
24667         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24668         ndr->depth++;
24669         if (flags & NDR_SET_VALUES) {
24670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24671         }
24672         if (flags & NDR_IN) {
24673                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24674                 ndr->depth++;
24675                 ndr->depth--;
24676         }
24677         if (flags & NDR_OUT) {
24678                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24679                 ndr->depth++;
24680                 ndr_print_WERROR(ndr, "result", r->out.result);
24681                 ndr->depth--;
24682         }
24683         ndr->depth--;
24684 }
24685
24686 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24687 {
24688         if (flags & NDR_IN) {
24689         }
24690         if (flags & NDR_OUT) {
24691                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24692         }
24693         return NDR_ERR_SUCCESS;
24694 }
24695
24696 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24697 {
24698         if (flags & NDR_IN) {
24699         }
24700         if (flags & NDR_OUT) {
24701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24702         }
24703         return NDR_ERR_SUCCESS;
24704 }
24705
24706 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24707 {
24708         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24709         ndr->depth++;
24710         if (flags & NDR_SET_VALUES) {
24711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24712         }
24713         if (flags & NDR_IN) {
24714                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24715                 ndr->depth++;
24716                 ndr->depth--;
24717         }
24718         if (flags & NDR_OUT) {
24719                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24720                 ndr->depth++;
24721                 ndr_print_WERROR(ndr, "result", r->out.result);
24722                 ndr->depth--;
24723         }
24724         ndr->depth--;
24725 }
24726
24727 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24728 {
24729         if (flags & NDR_IN) {
24730         }
24731         if (flags & NDR_OUT) {
24732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24733         }
24734         return NDR_ERR_SUCCESS;
24735 }
24736
24737 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24738 {
24739         if (flags & NDR_IN) {
24740         }
24741         if (flags & NDR_OUT) {
24742                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24743         }
24744         return NDR_ERR_SUCCESS;
24745 }
24746
24747 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24748 {
24749         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24750         ndr->depth++;
24751         if (flags & NDR_SET_VALUES) {
24752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24753         }
24754         if (flags & NDR_IN) {
24755                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24756                 ndr->depth++;
24757                 ndr->depth--;
24758         }
24759         if (flags & NDR_OUT) {
24760                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24761                 ndr->depth++;
24762                 ndr_print_WERROR(ndr, "result", r->out.result);
24763                 ndr->depth--;
24764         }
24765         ndr->depth--;
24766 }
24767
24768 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24769 {
24770         if (flags & NDR_IN) {
24771                 if (r->in.handle == NULL) {
24772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24773                 }
24774                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24775                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24777                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24778                 if (r->in.local_machine) {
24779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24782                         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));
24783                 }
24784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24786                 if (r->in.notify_options) {
24787                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24788                 }
24789         }
24790         if (flags & NDR_OUT) {
24791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24792         }
24793         return NDR_ERR_SUCCESS;
24794 }
24795
24796 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24797 {
24798         uint32_t _ptr_local_machine;
24799         uint32_t _ptr_notify_options;
24800         TALLOC_CTX *_mem_save_handle_0;
24801         TALLOC_CTX *_mem_save_local_machine_0;
24802         TALLOC_CTX *_mem_save_notify_options_0;
24803         if (flags & NDR_IN) {
24804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24805                         NDR_PULL_ALLOC(ndr, r->in.handle);
24806                 }
24807                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24808                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24809                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24811                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24814                 if (_ptr_local_machine) {
24815                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24816                 } else {
24817                         r->in.local_machine = NULL;
24818                 }
24819                 if (r->in.local_machine) {
24820                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24821                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24822                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24823                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24824                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24825                                 return 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));
24826                         }
24827                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24828                         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));
24829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24830                 }
24831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24833                 if (_ptr_notify_options) {
24834                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24835                 } else {
24836                         r->in.notify_options = NULL;
24837                 }
24838                 if (r->in.notify_options) {
24839                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24840                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24841                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24843                 }
24844         }
24845         if (flags & NDR_OUT) {
24846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24847         }
24848         return NDR_ERR_SUCCESS;
24849 }
24850
24851 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24852 {
24853         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24854         ndr->depth++;
24855         if (flags & NDR_SET_VALUES) {
24856                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24857         }
24858         if (flags & NDR_IN) {
24859                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24860                 ndr->depth++;
24861                 ndr_print_ptr(ndr, "handle", r->in.handle);
24862                 ndr->depth++;
24863                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24864                 ndr->depth--;
24865                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24866                 ndr_print_uint32(ndr, "options", r->in.options);
24867                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24868                 ndr->depth++;
24869                 if (r->in.local_machine) {
24870                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24871                 }
24872                 ndr->depth--;
24873                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24874                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24875                 ndr->depth++;
24876                 if (r->in.notify_options) {
24877                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24878                 }
24879                 ndr->depth--;
24880                 ndr->depth--;
24881         }
24882         if (flags & NDR_OUT) {
24883                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24884                 ndr->depth++;
24885                 ndr_print_WERROR(ndr, "result", r->out.result);
24886                 ndr->depth--;
24887         }
24888         ndr->depth--;
24889 }
24890
24891 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24892 {
24893         if (flags & NDR_IN) {
24894                 if (r->in.handle == NULL) {
24895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24896                 }
24897                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24899                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24901                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24902                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24903         }
24904         if (flags & NDR_OUT) {
24905                 if (r->out.reply_result == NULL) {
24906                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24907                 }
24908                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24910         }
24911         return NDR_ERR_SUCCESS;
24912 }
24913
24914 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24915 {
24916         TALLOC_CTX *_mem_save_handle_0;
24917         TALLOC_CTX *_mem_save_reply_result_0;
24918         if (flags & NDR_IN) {
24919                 ZERO_STRUCT(r->out);
24920
24921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24922                         NDR_PULL_ALLOC(ndr, r->in.handle);
24923                 }
24924                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24926                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24929                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24931                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24932                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24933                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24934                 ZERO_STRUCTP(r->out.reply_result);
24935         }
24936         if (flags & NDR_OUT) {
24937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24938                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24939                 }
24940                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24941                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24942                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24945         }
24946         return NDR_ERR_SUCCESS;
24947 }
24948
24949 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24950 {
24951         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24952         ndr->depth++;
24953         if (flags & NDR_SET_VALUES) {
24954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24955         }
24956         if (flags & NDR_IN) {
24957                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
24958                 ndr->depth++;
24959                 ndr_print_ptr(ndr, "handle", r->in.handle);
24960                 ndr->depth++;
24961                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24962                 ndr->depth--;
24963                 ndr_print_uint32(ndr, "color", r->in.color);
24964                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24965                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
24966                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
24967                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
24968                 ndr->depth--;
24969         }
24970         if (flags & NDR_OUT) {
24971                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
24972                 ndr->depth++;
24973                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
24974                 ndr->depth++;
24975                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
24976                 ndr->depth--;
24977                 ndr_print_WERROR(ndr, "result", r->out.result);
24978                 ndr->depth--;
24979         }
24980         ndr->depth--;
24981 }
24982
24983 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24984 {
24985         if (flags & NDR_IN) {
24986                 if (r->in.handle == NULL) {
24987                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24988                 }
24989                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
24991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
24992                 if (r->in.options) {
24993                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24994                 }
24995         }
24996         if (flags & NDR_OUT) {
24997                 if (r->out.info == NULL) {
24998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24999                 }
25000                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25001                 if (*r->out.info) {
25002                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25003                 }
25004                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25005         }
25006         return NDR_ERR_SUCCESS;
25007 }
25008
25009 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25010 {
25011         uint32_t _ptr_options;
25012         uint32_t _ptr_info;
25013         TALLOC_CTX *_mem_save_handle_0;
25014         TALLOC_CTX *_mem_save_options_0;
25015         TALLOC_CTX *_mem_save_info_0;
25016         TALLOC_CTX *_mem_save_info_1;
25017         if (flags & NDR_IN) {
25018                 ZERO_STRUCT(r->out);
25019
25020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25021                         NDR_PULL_ALLOC(ndr, r->in.handle);
25022                 }
25023                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25024                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25025                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25029                 if (_ptr_options) {
25030                         NDR_PULL_ALLOC(ndr, r->in.options);
25031                 } else {
25032                         r->in.options = NULL;
25033                 }
25034                 if (r->in.options) {
25035                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25036                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25037                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25039                 }
25040                 NDR_PULL_ALLOC(ndr, r->out.info);
25041                 ZERO_STRUCTP(r->out.info);
25042         }
25043         if (flags & NDR_OUT) {
25044                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25045                         NDR_PULL_ALLOC(ndr, r->out.info);
25046                 }
25047                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25048                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25049                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25050                 if (_ptr_info) {
25051                         NDR_PULL_ALLOC(ndr, *r->out.info);
25052                 } else {
25053                         *r->out.info = NULL;
25054                 }
25055                 if (*r->out.info) {
25056                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25057                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25058                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25060                 }
25061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25063         }
25064         return NDR_ERR_SUCCESS;
25065 }
25066
25067 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25068 {
25069         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25070         ndr->depth++;
25071         if (flags & NDR_SET_VALUES) {
25072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25073         }
25074         if (flags & NDR_IN) {
25075                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25076                 ndr->depth++;
25077                 ndr_print_ptr(ndr, "handle", r->in.handle);
25078                 ndr->depth++;
25079                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25080                 ndr->depth--;
25081                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25082                 ndr_print_ptr(ndr, "options", r->in.options);
25083                 ndr->depth++;
25084                 if (r->in.options) {
25085                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25086                 }
25087                 ndr->depth--;
25088                 ndr->depth--;
25089         }
25090         if (flags & NDR_OUT) {
25091                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25092                 ndr->depth++;
25093                 ndr_print_ptr(ndr, "info", r->out.info);
25094                 ndr->depth++;
25095                 ndr_print_ptr(ndr, "info", *r->out.info);
25096                 ndr->depth++;
25097                 if (*r->out.info) {
25098                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25099                 }
25100                 ndr->depth--;
25101                 ndr->depth--;
25102                 ndr_print_WERROR(ndr, "result", r->out.result);
25103                 ndr->depth--;
25104         }
25105         ndr->depth--;
25106 }
25107
25108 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25109 {
25110         if (flags & NDR_IN) {
25111         }
25112         if (flags & NDR_OUT) {
25113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25114         }
25115         return NDR_ERR_SUCCESS;
25116 }
25117
25118 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25119 {
25120         if (flags & NDR_IN) {
25121         }
25122         if (flags & NDR_OUT) {
25123                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25124         }
25125         return NDR_ERR_SUCCESS;
25126 }
25127
25128 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25129 {
25130         ndr_print_struct(ndr, name, "spoolss_44");
25131         ndr->depth++;
25132         if (flags & NDR_SET_VALUES) {
25133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25134         }
25135         if (flags & NDR_IN) {
25136                 ndr_print_struct(ndr, "in", "spoolss_44");
25137                 ndr->depth++;
25138                 ndr->depth--;
25139         }
25140         if (flags & NDR_OUT) {
25141                 ndr_print_struct(ndr, "out", "spoolss_44");
25142                 ndr->depth++;
25143                 ndr_print_WERROR(ndr, "result", r->out.result);
25144                 ndr->depth--;
25145         }
25146         ndr->depth--;
25147 }
25148
25149 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25150 {
25151         if (flags & NDR_IN) {
25152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25153                 if (r->in.printername) {
25154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25158                 }
25159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25160                 if (r->in.datatype) {
25161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25164                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25165                 }
25166                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25167                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25169                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25170                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25171         }
25172         if (flags & NDR_OUT) {
25173                 if (r->out.handle == NULL) {
25174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25175                 }
25176                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25177                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25178         }
25179         return NDR_ERR_SUCCESS;
25180 }
25181
25182 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25183 {
25184         uint32_t _ptr_printername;
25185         uint32_t _ptr_datatype;
25186         TALLOC_CTX *_mem_save_printername_0;
25187         TALLOC_CTX *_mem_save_datatype_0;
25188         TALLOC_CTX *_mem_save_handle_0;
25189         if (flags & NDR_IN) {
25190                 ZERO_STRUCT(r->out);
25191
25192                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25193                 if (_ptr_printername) {
25194                         NDR_PULL_ALLOC(ndr, r->in.printername);
25195                 } else {
25196                         r->in.printername = NULL;
25197                 }
25198                 if (r->in.printername) {
25199                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25200                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25202                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25203                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25204                                 return 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));
25205                         }
25206                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25207                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25209                 }
25210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25211                 if (_ptr_datatype) {
25212                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25213                 } else {
25214                         r->in.datatype = NULL;
25215                 }
25216                 if (r->in.datatype) {
25217                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25218                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25221                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25222                                 return 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));
25223                         }
25224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25225                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25227                 }
25228                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25229                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25231                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25232                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25233                 NDR_PULL_ALLOC(ndr, r->out.handle);
25234                 ZERO_STRUCTP(r->out.handle);
25235         }
25236         if (flags & NDR_OUT) {
25237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25238                         NDR_PULL_ALLOC(ndr, r->out.handle);
25239                 }
25240                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25241                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25242                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25243                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25244                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25245         }
25246         return NDR_ERR_SUCCESS;
25247 }
25248
25249 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25250 {
25251         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25252         ndr->depth++;
25253         if (flags & NDR_SET_VALUES) {
25254                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25255         }
25256         if (flags & NDR_IN) {
25257                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25258                 ndr->depth++;
25259                 ndr_print_ptr(ndr, "printername", r->in.printername);
25260                 ndr->depth++;
25261                 if (r->in.printername) {
25262                         ndr_print_string(ndr, "printername", r->in.printername);
25263                 }
25264                 ndr->depth--;
25265                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25266                 ndr->depth++;
25267                 if (r->in.datatype) {
25268                         ndr_print_string(ndr, "datatype", r->in.datatype);
25269                 }
25270                 ndr->depth--;
25271                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25272                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25273                 ndr_print_uint32(ndr, "level", r->in.level);
25274                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25275                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25276                 ndr->depth--;
25277         }
25278         if (flags & NDR_OUT) {
25279                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25280                 ndr->depth++;
25281                 ndr_print_ptr(ndr, "handle", r->out.handle);
25282                 ndr->depth++;
25283                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25284                 ndr->depth--;
25285                 ndr_print_WERROR(ndr, "result", r->out.result);
25286                 ndr->depth--;
25287         }
25288         ndr->depth--;
25289 }
25290
25291 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25292 {
25293         if (flags & NDR_IN) {
25294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25295                 if (r->in.server) {
25296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25300                 }
25301                 if (r->in.info_ctr == NULL) {
25302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25303                 }
25304                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25305                 if (r->in.devmode_ctr == NULL) {
25306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25307                 }
25308                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25309                 if (r->in.secdesc_ctr == NULL) {
25310                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25311                 }
25312                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25313                 if (r->in.userlevel_ctr == NULL) {
25314                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25315                 }
25316                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25317         }
25318         if (flags & NDR_OUT) {
25319                 if (r->out.handle == NULL) {
25320                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25321                 }
25322                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25323                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25324         }
25325         return NDR_ERR_SUCCESS;
25326 }
25327
25328 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25329 {
25330         uint32_t _ptr_server;
25331         TALLOC_CTX *_mem_save_server_0;
25332         TALLOC_CTX *_mem_save_info_ctr_0;
25333         TALLOC_CTX *_mem_save_devmode_ctr_0;
25334         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25335         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25336         TALLOC_CTX *_mem_save_handle_0;
25337         if (flags & NDR_IN) {
25338                 ZERO_STRUCT(r->out);
25339
25340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25341                 if (_ptr_server) {
25342                         NDR_PULL_ALLOC(ndr, r->in.server);
25343                 } else {
25344                         r->in.server = NULL;
25345                 }
25346                 if (r->in.server) {
25347                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25348                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25349                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25350                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25351                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25352                                 return 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));
25353                         }
25354                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25355                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25356                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25357                 }
25358                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25359                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25360                 }
25361                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25362                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25363                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25366                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25367                 }
25368                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25370                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25372                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25373                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25374                 }
25375                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25376                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25377                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25379                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25380                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25381                 }
25382                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25383                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25384                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25385                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25386                 NDR_PULL_ALLOC(ndr, r->out.handle);
25387                 ZERO_STRUCTP(r->out.handle);
25388         }
25389         if (flags & NDR_OUT) {
25390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25391                         NDR_PULL_ALLOC(ndr, r->out.handle);
25392                 }
25393                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25394                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25395                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25397                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25398         }
25399         return NDR_ERR_SUCCESS;
25400 }
25401
25402 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25403 {
25404         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25405         ndr->depth++;
25406         if (flags & NDR_SET_VALUES) {
25407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25408         }
25409         if (flags & NDR_IN) {
25410                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25411                 ndr->depth++;
25412                 ndr_print_ptr(ndr, "server", r->in.server);
25413                 ndr->depth++;
25414                 if (r->in.server) {
25415                         ndr_print_string(ndr, "server", r->in.server);
25416                 }
25417                 ndr->depth--;
25418                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25419                 ndr->depth++;
25420                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25421                 ndr->depth--;
25422                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25423                 ndr->depth++;
25424                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25425                 ndr->depth--;
25426                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25427                 ndr->depth++;
25428                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25429                 ndr->depth--;
25430                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25431                 ndr->depth++;
25432                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25433                 ndr->depth--;
25434                 ndr->depth--;
25435         }
25436         if (flags & NDR_OUT) {
25437                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25438                 ndr->depth++;
25439                 ndr_print_ptr(ndr, "handle", r->out.handle);
25440                 ndr->depth++;
25441                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25442                 ndr->depth--;
25443                 ndr_print_WERROR(ndr, "result", r->out.result);
25444                 ndr->depth--;
25445         }
25446         ndr->depth--;
25447 }
25448
25449 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25450 {
25451         if (flags & NDR_IN) {
25452         }
25453         if (flags & NDR_OUT) {
25454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25455         }
25456         return NDR_ERR_SUCCESS;
25457 }
25458
25459 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25460 {
25461         if (flags & NDR_IN) {
25462         }
25463         if (flags & NDR_OUT) {
25464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25465         }
25466         return NDR_ERR_SUCCESS;
25467 }
25468
25469 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25470 {
25471         ndr_print_struct(ndr, name, "spoolss_47");
25472         ndr->depth++;
25473         if (flags & NDR_SET_VALUES) {
25474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25475         }
25476         if (flags & NDR_IN) {
25477                 ndr_print_struct(ndr, "in", "spoolss_47");
25478                 ndr->depth++;
25479                 ndr->depth--;
25480         }
25481         if (flags & NDR_OUT) {
25482                 ndr_print_struct(ndr, "out", "spoolss_47");
25483                 ndr->depth++;
25484                 ndr_print_WERROR(ndr, "result", r->out.result);
25485                 ndr->depth--;
25486         }
25487         ndr->depth--;
25488 }
25489
25490 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25491 {
25492         if (flags & NDR_IN) {
25493                 if (r->in.handle == NULL) {
25494                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25495                 }
25496                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25498                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25500         }
25501         if (flags & NDR_OUT) {
25502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25503                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25504                 if (r->out.value_needed == NULL) {
25505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25506                 }
25507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25508                 if (r->out.printerdata_type == NULL) {
25509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25510                 }
25511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25512                 if (r->out.buffer == NULL) {
25513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25514                 }
25515                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25516                 if (r->out.data_needed == NULL) {
25517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25518                 }
25519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25520                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25521         }
25522         return NDR_ERR_SUCCESS;
25523 }
25524
25525 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25526 {
25527         TALLOC_CTX *_mem_save_handle_0;
25528         TALLOC_CTX *_mem_save_value_needed_0;
25529         TALLOC_CTX *_mem_save_printerdata_type_0;
25530         TALLOC_CTX *_mem_save_buffer_0;
25531         TALLOC_CTX *_mem_save_data_needed_0;
25532         if (flags & NDR_IN) {
25533                 ZERO_STRUCT(r->out);
25534
25535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25536                         NDR_PULL_ALLOC(ndr, r->in.handle);
25537                 }
25538                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25539                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25540                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25545                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25546                 ZERO_STRUCTP(r->out.value_needed);
25547                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25548                 ZERO_STRUCTP(r->out.printerdata_type);
25549                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25550                 ZERO_STRUCTP(r->out.buffer);
25551                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25552                 ZERO_STRUCTP(r->out.data_needed);
25553         }
25554         if (flags & NDR_OUT) {
25555                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25556                 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));
25557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25558                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25559                 }
25560                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25561                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25564                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25565                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25566                 }
25567                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25568                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25570                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25572                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25573                 }
25574                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25575                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25576                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25579                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25580                 }
25581                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25582                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25585                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25586                 if (r->out.value_name) {
25587                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25588                 }
25589         }
25590         return NDR_ERR_SUCCESS;
25591 }
25592
25593 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25594 {
25595         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25596         ndr->depth++;
25597         if (flags & NDR_SET_VALUES) {
25598                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25599         }
25600         if (flags & NDR_IN) {
25601                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25602                 ndr->depth++;
25603                 ndr_print_ptr(ndr, "handle", r->in.handle);
25604                 ndr->depth++;
25605                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25606                 ndr->depth--;
25607                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25608                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25609                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25610                 ndr->depth--;
25611         }
25612         if (flags & NDR_OUT) {
25613                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25614                 ndr->depth++;
25615                 ndr_print_string(ndr, "value_name", r->out.value_name);
25616                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25617                 ndr->depth++;
25618                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25619                 ndr->depth--;
25620                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25621                 ndr->depth++;
25622                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25623                 ndr->depth--;
25624                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25625                 ndr->depth++;
25626                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25627                 ndr->depth--;
25628                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25629                 ndr->depth++;
25630                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25631                 ndr->depth--;
25632                 ndr_print_WERROR(ndr, "result", r->out.result);
25633                 ndr->depth--;
25634         }
25635         ndr->depth--;
25636 }
25637
25638 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25639 {
25640         if (flags & NDR_IN) {
25641                 if (r->in.handle == NULL) {
25642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25643                 }
25644                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25648                 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));
25649         }
25650         if (flags & NDR_OUT) {
25651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25652         }
25653         return NDR_ERR_SUCCESS;
25654 }
25655
25656 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25657 {
25658         TALLOC_CTX *_mem_save_handle_0;
25659         if (flags & NDR_IN) {
25660                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25661                         NDR_PULL_ALLOC(ndr, r->in.handle);
25662                 }
25663                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25664                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25665                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25667                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25668                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25669                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25670                         return 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));
25671                 }
25672                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25673                 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));
25674         }
25675         if (flags & NDR_OUT) {
25676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25677         }
25678         return NDR_ERR_SUCCESS;
25679 }
25680
25681 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25682 {
25683         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25684         ndr->depth++;
25685         if (flags & NDR_SET_VALUES) {
25686                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25687         }
25688         if (flags & NDR_IN) {
25689                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25690                 ndr->depth++;
25691                 ndr_print_ptr(ndr, "handle", r->in.handle);
25692                 ndr->depth++;
25693                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25694                 ndr->depth--;
25695                 ndr_print_string(ndr, "value_name", r->in.value_name);
25696                 ndr->depth--;
25697         }
25698         if (flags & NDR_OUT) {
25699                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25700                 ndr->depth++;
25701                 ndr_print_WERROR(ndr, "result", r->out.result);
25702                 ndr->depth--;
25703         }
25704         ndr->depth--;
25705 }
25706
25707 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25708 {
25709         if (flags & NDR_IN) {
25710         }
25711         if (flags & NDR_OUT) {
25712                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25713         }
25714         return NDR_ERR_SUCCESS;
25715 }
25716
25717 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25718 {
25719         if (flags & NDR_IN) {
25720         }
25721         if (flags & NDR_OUT) {
25722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25723         }
25724         return NDR_ERR_SUCCESS;
25725 }
25726
25727 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25728 {
25729         ndr_print_struct(ndr, name, "spoolss_4a");
25730         ndr->depth++;
25731         if (flags & NDR_SET_VALUES) {
25732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25733         }
25734         if (flags & NDR_IN) {
25735                 ndr_print_struct(ndr, "in", "spoolss_4a");
25736                 ndr->depth++;
25737                 ndr->depth--;
25738         }
25739         if (flags & NDR_OUT) {
25740                 ndr_print_struct(ndr, "out", "spoolss_4a");
25741                 ndr->depth++;
25742                 ndr_print_WERROR(ndr, "result", r->out.result);
25743                 ndr->depth--;
25744         }
25745         ndr->depth--;
25746 }
25747
25748 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25749 {
25750         if (flags & NDR_IN) {
25751         }
25752         if (flags & NDR_OUT) {
25753                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25754         }
25755         return NDR_ERR_SUCCESS;
25756 }
25757
25758 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25759 {
25760         if (flags & NDR_IN) {
25761         }
25762         if (flags & NDR_OUT) {
25763                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25764         }
25765         return NDR_ERR_SUCCESS;
25766 }
25767
25768 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25769 {
25770         ndr_print_struct(ndr, name, "spoolss_4b");
25771         ndr->depth++;
25772         if (flags & NDR_SET_VALUES) {
25773                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25774         }
25775         if (flags & NDR_IN) {
25776                 ndr_print_struct(ndr, "in", "spoolss_4b");
25777                 ndr->depth++;
25778                 ndr->depth--;
25779         }
25780         if (flags & NDR_OUT) {
25781                 ndr_print_struct(ndr, "out", "spoolss_4b");
25782                 ndr->depth++;
25783                 ndr_print_WERROR(ndr, "result", r->out.result);
25784                 ndr->depth--;
25785         }
25786         ndr->depth--;
25787 }
25788
25789 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25790 {
25791         if (flags & NDR_IN) {
25792         }
25793         if (flags & NDR_OUT) {
25794                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25795         }
25796         return NDR_ERR_SUCCESS;
25797 }
25798
25799 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25800 {
25801         if (flags & NDR_IN) {
25802         }
25803         if (flags & NDR_OUT) {
25804                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25805         }
25806         return NDR_ERR_SUCCESS;
25807 }
25808
25809 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25810 {
25811         ndr_print_struct(ndr, name, "spoolss_4c");
25812         ndr->depth++;
25813         if (flags & NDR_SET_VALUES) {
25814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25815         }
25816         if (flags & NDR_IN) {
25817                 ndr_print_struct(ndr, "in", "spoolss_4c");
25818                 ndr->depth++;
25819                 ndr->depth--;
25820         }
25821         if (flags & NDR_OUT) {
25822                 ndr_print_struct(ndr, "out", "spoolss_4c");
25823                 ndr->depth++;
25824                 ndr_print_WERROR(ndr, "result", r->out.result);
25825                 ndr->depth--;
25826         }
25827         ndr->depth--;
25828 }
25829
25830 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25831 {
25832         if (flags & NDR_IN) {
25833                 if (r->in.handle == NULL) {
25834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25835                 }
25836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25840                 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));
25841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25844                 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));
25845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25846                 if (r->in.buffer == NULL) {
25847                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25848                 }
25849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25850                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25852         }
25853         if (flags & NDR_OUT) {
25854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25855         }
25856         return NDR_ERR_SUCCESS;
25857 }
25858
25859 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25860 {
25861         TALLOC_CTX *_mem_save_handle_0;
25862         if (flags & NDR_IN) {
25863                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25864                         NDR_PULL_ALLOC(ndr, r->in.handle);
25865                 }
25866                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25867                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25868                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25870                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25871                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25872                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25873                         return 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));
25874                 }
25875                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25876                 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));
25877                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25878                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25879                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25880                         return 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));
25881                 }
25882                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25883                 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));
25884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25885                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25886                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25887                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25888                 }
25889                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25891                 if (r->in.buffer) {
25892                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25893                 }
25894         }
25895         if (flags & NDR_OUT) {
25896                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25897         }
25898         return NDR_ERR_SUCCESS;
25899 }
25900
25901 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25902 {
25903         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25904         ndr->depth++;
25905         if (flags & NDR_SET_VALUES) {
25906                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25907         }
25908         if (flags & NDR_IN) {
25909                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25910                 ndr->depth++;
25911                 ndr_print_ptr(ndr, "handle", r->in.handle);
25912                 ndr->depth++;
25913                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25914                 ndr->depth--;
25915                 ndr_print_string(ndr, "key_name", r->in.key_name);
25916                 ndr_print_string(ndr, "value_name", r->in.value_name);
25917                 ndr_print_uint32(ndr, "type", r->in.type);
25918                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25919                 ndr->depth++;
25920                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25921                 ndr->depth--;
25922                 ndr_print_uint32(ndr, "offered", r->in.offered);
25923                 ndr->depth--;
25924         }
25925         if (flags & NDR_OUT) {
25926                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25927                 ndr->depth++;
25928                 ndr_print_WERROR(ndr, "result", r->out.result);
25929                 ndr->depth--;
25930         }
25931         ndr->depth--;
25932 }
25933
25934 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25935 {
25936         if (flags & NDR_IN) {
25937                 if (r->in.handle == NULL) {
25938                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25939                 }
25940                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25944                 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));
25945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25948                 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));
25949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25950         }
25951         if (flags & NDR_OUT) {
25952                 if (r->out.type == NULL) {
25953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25954                 }
25955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
25956                 if (r->out.buffer == NULL) {
25957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25958                 }
25959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25960                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25961                 if (r->out.needed == NULL) {
25962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25963                 }
25964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25965                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25966         }
25967         return NDR_ERR_SUCCESS;
25968 }
25969
25970 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
25971 {
25972         TALLOC_CTX *_mem_save_handle_0;
25973         TALLOC_CTX *_mem_save_type_0;
25974         TALLOC_CTX *_mem_save_needed_0;
25975         if (flags & NDR_IN) {
25976                 ZERO_STRUCT(r->out);
25977
25978                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25979                         NDR_PULL_ALLOC(ndr, r->in.handle);
25980                 }
25981                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25982                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25983                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25984                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25986                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25987                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25988                         return 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));
25989                 }
25990                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25991                 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));
25992                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25993                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25994                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25995                         return 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));
25996                 }
25997                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25998                 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));
25999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26000                 NDR_PULL_ALLOC(ndr, r->out.type);
26001                 ZERO_STRUCTP(r->out.type);
26002                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26003                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26004                 NDR_PULL_ALLOC(ndr, r->out.needed);
26005                 ZERO_STRUCTP(r->out.needed);
26006         }
26007         if (flags & NDR_OUT) {
26008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26009                         NDR_PULL_ALLOC(ndr, r->out.type);
26010                 }
26011                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
26014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26015                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26016                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26017                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26018                 }
26019                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26021                         NDR_PULL_ALLOC(ndr, r->out.needed);
26022                 }
26023                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26028                 if (r->out.buffer) {
26029                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26030                 }
26031         }
26032         return NDR_ERR_SUCCESS;
26033 }
26034
26035 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26036 {
26037         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26038         ndr->depth++;
26039         if (flags & NDR_SET_VALUES) {
26040                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26041         }
26042         if (flags & NDR_IN) {
26043                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26044                 ndr->depth++;
26045                 ndr_print_ptr(ndr, "handle", r->in.handle);
26046                 ndr->depth++;
26047                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26048                 ndr->depth--;
26049                 ndr_print_string(ndr, "key_name", r->in.key_name);
26050                 ndr_print_string(ndr, "value_name", r->in.value_name);
26051                 ndr_print_uint32(ndr, "offered", r->in.offered);
26052                 ndr->depth--;
26053         }
26054         if (flags & NDR_OUT) {
26055                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26056                 ndr->depth++;
26057                 ndr_print_ptr(ndr, "type", r->out.type);
26058                 ndr->depth++;
26059                 ndr_print_uint32(ndr, "type", *r->out.type);
26060                 ndr->depth--;
26061                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26062                 ndr->depth++;
26063                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26064                 ndr->depth--;
26065                 ndr_print_ptr(ndr, "needed", r->out.needed);
26066                 ndr->depth++;
26067                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26068                 ndr->depth--;
26069                 ndr_print_WERROR(ndr, "result", r->out.result);
26070                 ndr->depth--;
26071         }
26072         ndr->depth--;
26073 }
26074
26075 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26076 {
26077         if (flags & NDR_IN) {
26078                 if (r->in.handle == NULL) {
26079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26080                 }
26081                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26085                 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));
26086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26087         }
26088         if (flags & NDR_OUT) {
26089                 if (r->out.buffer == 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->in.offered));
26093                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26094                 if (r->out.needed == NULL) {
26095                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26096                 }
26097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26098                 if (r->out.count == NULL) {
26099                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26100                 }
26101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26103         }
26104         return NDR_ERR_SUCCESS;
26105 }
26106
26107 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26108 {
26109         TALLOC_CTX *_mem_save_handle_0;
26110         TALLOC_CTX *_mem_save_needed_0;
26111         TALLOC_CTX *_mem_save_count_0;
26112         if (flags & NDR_IN) {
26113                 ZERO_STRUCT(r->out);
26114
26115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26116                         NDR_PULL_ALLOC(ndr, r->in.handle);
26117                 }
26118                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26119                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26120                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26121                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26122                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26123                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26124                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26125                         return 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));
26126                 }
26127                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26128                 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));
26129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26130                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26131                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26132                 NDR_PULL_ALLOC(ndr, r->out.needed);
26133                 ZERO_STRUCTP(r->out.needed);
26134                 NDR_PULL_ALLOC(ndr, r->out.count);
26135                 ZERO_STRUCTP(r->out.count);
26136         }
26137         if (flags & NDR_OUT) {
26138                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26140                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26141                 }
26142                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26143                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26144                         NDR_PULL_ALLOC(ndr, r->out.needed);
26145                 }
26146                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26147                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26151                         NDR_PULL_ALLOC(ndr, r->out.count);
26152                 }
26153                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26154                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26157                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26158                 if (r->out.buffer) {
26159                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26160                 }
26161         }
26162         return NDR_ERR_SUCCESS;
26163 }
26164
26165 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26166 {
26167         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26168         ndr->depth++;
26169         if (flags & NDR_SET_VALUES) {
26170                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26171         }
26172         if (flags & NDR_IN) {
26173                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26174                 ndr->depth++;
26175                 ndr_print_ptr(ndr, "handle", r->in.handle);
26176                 ndr->depth++;
26177                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26178                 ndr->depth--;
26179                 ndr_print_string(ndr, "key_name", r->in.key_name);
26180                 ndr_print_uint32(ndr, "offered", r->in.offered);
26181                 ndr->depth--;
26182         }
26183         if (flags & NDR_OUT) {
26184                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26185                 ndr->depth++;
26186                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26187                 ndr->depth++;
26188                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26189                 ndr->depth--;
26190                 ndr_print_ptr(ndr, "needed", r->out.needed);
26191                 ndr->depth++;
26192                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26193                 ndr->depth--;
26194                 ndr_print_ptr(ndr, "count", r->out.count);
26195                 ndr->depth++;
26196                 ndr_print_uint32(ndr, "count", *r->out.count);
26197                 ndr->depth--;
26198                 ndr_print_WERROR(ndr, "result", r->out.result);
26199                 ndr->depth--;
26200         }
26201         ndr->depth--;
26202 }
26203
26204 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26205 {
26206         uint32_t cntr_key_buffer_1;
26207         if (flags & NDR_IN) {
26208                 if (r->in.handle == NULL) {
26209                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26210                 }
26211                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26215                 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));
26216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
26217         }
26218         if (flags & NDR_OUT) {
26219                 if (r->out.key_buffer == NULL) {
26220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26221                 }
26222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
26223                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26224                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26225                 }
26226                 if (r->out.needed == NULL) {
26227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26228                 }
26229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26230                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26231         }
26232         return NDR_ERR_SUCCESS;
26233 }
26234
26235 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26236 {
26237         uint32_t cntr_key_buffer_1;
26238         TALLOC_CTX *_mem_save_handle_0;
26239         TALLOC_CTX *_mem_save_key_buffer_1;
26240         TALLOC_CTX *_mem_save_needed_0;
26241         if (flags & NDR_IN) {
26242                 ZERO_STRUCT(r->out);
26243
26244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26245                         NDR_PULL_ALLOC(ndr, r->in.handle);
26246                 }
26247                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26248                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26249                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26251                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26252                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26253                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26254                         return 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));
26255                 }
26256                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26257                 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));
26258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
26259                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
26260                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
26261                 NDR_PULL_ALLOC(ndr, r->out.needed);
26262                 ZERO_STRUCTP(r->out.needed);
26263         }
26264         if (flags & NDR_OUT) {
26265                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26267                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26268                 }
26269                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26270                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26271                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26272                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26273                 }
26274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26275                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26276                         NDR_PULL_ALLOC(ndr, r->out.needed);
26277                 }
26278                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26279                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26283                 if (r->out.key_buffer) {
26284                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
26285                 }
26286         }
26287         return NDR_ERR_SUCCESS;
26288 }
26289
26290 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26291 {
26292         uint32_t cntr_key_buffer_1;
26293         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26294         ndr->depth++;
26295         if (flags & NDR_SET_VALUES) {
26296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26297         }
26298         if (flags & NDR_IN) {
26299                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26300                 ndr->depth++;
26301                 ndr_print_ptr(ndr, "handle", r->in.handle);
26302                 ndr->depth++;
26303                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26304                 ndr->depth--;
26305                 ndr_print_string(ndr, "key_name", r->in.key_name);
26306                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
26307                 ndr->depth--;
26308         }
26309         if (flags & NDR_OUT) {
26310                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26311                 ndr->depth++;
26312                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26313                 ndr->depth++;
26314                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
26315                 ndr->depth++;
26316                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
26317                         char *idx_1=NULL;
26318                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26319                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26320                                 free(idx_1);
26321                         }
26322                 }
26323                 ndr->depth--;
26324                 ndr->depth--;
26325                 ndr_print_ptr(ndr, "needed", r->out.needed);
26326                 ndr->depth++;
26327                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26328                 ndr->depth--;
26329                 ndr_print_WERROR(ndr, "result", r->out.result);
26330                 ndr->depth--;
26331         }
26332         ndr->depth--;
26333 }
26334
26335 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26336 {
26337         if (flags & NDR_IN) {
26338                 if (r->in.handle == NULL) {
26339                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26340                 }
26341                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26345                 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));
26346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26349                 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));
26350         }
26351         if (flags & NDR_OUT) {
26352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26353         }
26354         return NDR_ERR_SUCCESS;
26355 }
26356
26357 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26358 {
26359         TALLOC_CTX *_mem_save_handle_0;
26360         if (flags & NDR_IN) {
26361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26362                         NDR_PULL_ALLOC(ndr, r->in.handle);
26363                 }
26364                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26365                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26368                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26369                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26370                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26371                         return 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));
26372                 }
26373                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26374                 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));
26375                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26376                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26377                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26378                         return 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));
26379                 }
26380                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26381                 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));
26382         }
26383         if (flags & NDR_OUT) {
26384                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26385         }
26386         return NDR_ERR_SUCCESS;
26387 }
26388
26389 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26390 {
26391         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26392         ndr->depth++;
26393         if (flags & NDR_SET_VALUES) {
26394                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26395         }
26396         if (flags & NDR_IN) {
26397                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26398                 ndr->depth++;
26399                 ndr_print_ptr(ndr, "handle", r->in.handle);
26400                 ndr->depth++;
26401                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26402                 ndr->depth--;
26403                 ndr_print_string(ndr, "key_name", r->in.key_name);
26404                 ndr_print_string(ndr, "value_name", r->in.value_name);
26405                 ndr->depth--;
26406         }
26407         if (flags & NDR_OUT) {
26408                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26409                 ndr->depth++;
26410                 ndr_print_WERROR(ndr, "result", r->out.result);
26411                 ndr->depth--;
26412         }
26413         ndr->depth--;
26414 }
26415
26416 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26417 {
26418         if (flags & NDR_IN) {
26419                 if (r->in.handle == NULL) {
26420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26421                 }
26422                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26426                 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));
26427         }
26428         if (flags & NDR_OUT) {
26429                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26430         }
26431         return NDR_ERR_SUCCESS;
26432 }
26433
26434 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26435 {
26436         TALLOC_CTX *_mem_save_handle_0;
26437         if (flags & NDR_IN) {
26438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26439                         NDR_PULL_ALLOC(ndr, r->in.handle);
26440                 }
26441                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26445                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26446                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26447                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26448                         return 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));
26449                 }
26450                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26451                 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));
26452         }
26453         if (flags & NDR_OUT) {
26454                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26455         }
26456         return NDR_ERR_SUCCESS;
26457 }
26458
26459 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26460 {
26461         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26462         ndr->depth++;
26463         if (flags & NDR_SET_VALUES) {
26464                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26465         }
26466         if (flags & NDR_IN) {
26467                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26468                 ndr->depth++;
26469                 ndr_print_ptr(ndr, "handle", r->in.handle);
26470                 ndr->depth++;
26471                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26472                 ndr->depth--;
26473                 ndr_print_string(ndr, "key_name", r->in.key_name);
26474                 ndr->depth--;
26475         }
26476         if (flags & NDR_OUT) {
26477                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26478                 ndr->depth++;
26479                 ndr_print_WERROR(ndr, "result", r->out.result);
26480                 ndr->depth--;
26481         }
26482         ndr->depth--;
26483 }
26484
26485 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26486 {
26487         if (flags & NDR_IN) {
26488         }
26489         if (flags & NDR_OUT) {
26490                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26491         }
26492         return NDR_ERR_SUCCESS;
26493 }
26494
26495 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26496 {
26497         if (flags & NDR_IN) {
26498         }
26499         if (flags & NDR_OUT) {
26500                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26501         }
26502         return NDR_ERR_SUCCESS;
26503 }
26504
26505 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26506 {
26507         ndr_print_struct(ndr, name, "spoolss_53");
26508         ndr->depth++;
26509         if (flags & NDR_SET_VALUES) {
26510                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26511         }
26512         if (flags & NDR_IN) {
26513                 ndr_print_struct(ndr, "in", "spoolss_53");
26514                 ndr->depth++;
26515                 ndr->depth--;
26516         }
26517         if (flags & NDR_OUT) {
26518                 ndr_print_struct(ndr, "out", "spoolss_53");
26519                 ndr->depth++;
26520                 ndr_print_WERROR(ndr, "result", r->out.result);
26521                 ndr->depth--;
26522         }
26523         ndr->depth--;
26524 }
26525
26526 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26527 {
26528         if (flags & NDR_IN) {
26529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26530                 if (r->in.server) {
26531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26534                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26535                 }
26536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26539                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26543                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26544                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26546         }
26547         if (flags & NDR_OUT) {
26548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26549         }
26550         return NDR_ERR_SUCCESS;
26551 }
26552
26553 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26554 {
26555         uint32_t _ptr_server;
26556         TALLOC_CTX *_mem_save_server_0;
26557         if (flags & NDR_IN) {
26558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26559                 if (_ptr_server) {
26560                         NDR_PULL_ALLOC(ndr, r->in.server);
26561                 } else {
26562                         r->in.server = NULL;
26563                 }
26564                 if (r->in.server) {
26565                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26566                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26569                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26570                                 return 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));
26571                         }
26572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26575                 }
26576                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26577                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26578                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26579                         return 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));
26580                 }
26581                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26582                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26583                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26584                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26585                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26586                         return 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));
26587                 }
26588                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26589                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26590                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26592         }
26593         if (flags & NDR_OUT) {
26594                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26595         }
26596         return NDR_ERR_SUCCESS;
26597 }
26598
26599 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26600 {
26601         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26602         ndr->depth++;
26603         if (flags & NDR_SET_VALUES) {
26604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26605         }
26606         if (flags & NDR_IN) {
26607                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26608                 ndr->depth++;
26609                 ndr_print_ptr(ndr, "server", r->in.server);
26610                 ndr->depth++;
26611                 if (r->in.server) {
26612                         ndr_print_string(ndr, "server", r->in.server);
26613                 }
26614                 ndr->depth--;
26615                 ndr_print_string(ndr, "architecture", r->in.architecture);
26616                 ndr_print_string(ndr, "driver", r->in.driver);
26617                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26618                 ndr_print_uint32(ndr, "version", r->in.version);
26619                 ndr->depth--;
26620         }
26621         if (flags & NDR_OUT) {
26622                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26623                 ndr->depth++;
26624                 ndr_print_WERROR(ndr, "result", r->out.result);
26625                 ndr->depth--;
26626         }
26627         ndr->depth--;
26628 }
26629
26630 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26631 {
26632         if (flags & NDR_IN) {
26633         }
26634         if (flags & NDR_OUT) {
26635                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26636         }
26637         return NDR_ERR_SUCCESS;
26638 }
26639
26640 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26641 {
26642         if (flags & NDR_IN) {
26643         }
26644         if (flags & NDR_OUT) {
26645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26646         }
26647         return NDR_ERR_SUCCESS;
26648 }
26649
26650 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26651 {
26652         ndr_print_struct(ndr, name, "spoolss_55");
26653         ndr->depth++;
26654         if (flags & NDR_SET_VALUES) {
26655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26656         }
26657         if (flags & NDR_IN) {
26658                 ndr_print_struct(ndr, "in", "spoolss_55");
26659                 ndr->depth++;
26660                 ndr->depth--;
26661         }
26662         if (flags & NDR_OUT) {
26663                 ndr_print_struct(ndr, "out", "spoolss_55");
26664                 ndr->depth++;
26665                 ndr_print_WERROR(ndr, "result", r->out.result);
26666                 ndr->depth--;
26667         }
26668         ndr->depth--;
26669 }
26670
26671 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26672 {
26673         if (flags & NDR_IN) {
26674         }
26675         if (flags & NDR_OUT) {
26676                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26677         }
26678         return NDR_ERR_SUCCESS;
26679 }
26680
26681 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26682 {
26683         if (flags & NDR_IN) {
26684         }
26685         if (flags & NDR_OUT) {
26686                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26687         }
26688         return NDR_ERR_SUCCESS;
26689 }
26690
26691 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26692 {
26693         ndr_print_struct(ndr, name, "spoolss_56");
26694         ndr->depth++;
26695         if (flags & NDR_SET_VALUES) {
26696                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26697         }
26698         if (flags & NDR_IN) {
26699                 ndr_print_struct(ndr, "in", "spoolss_56");
26700                 ndr->depth++;
26701                 ndr->depth--;
26702         }
26703         if (flags & NDR_OUT) {
26704                 ndr_print_struct(ndr, "out", "spoolss_56");
26705                 ndr->depth++;
26706                 ndr_print_WERROR(ndr, "result", r->out.result);
26707                 ndr->depth--;
26708         }
26709         ndr->depth--;
26710 }
26711
26712 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26713 {
26714         if (flags & NDR_IN) {
26715         }
26716         if (flags & NDR_OUT) {
26717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26718         }
26719         return NDR_ERR_SUCCESS;
26720 }
26721
26722 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26723 {
26724         if (flags & NDR_IN) {
26725         }
26726         if (flags & NDR_OUT) {
26727                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26728         }
26729         return NDR_ERR_SUCCESS;
26730 }
26731
26732 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26733 {
26734         ndr_print_struct(ndr, name, "spoolss_57");
26735         ndr->depth++;
26736         if (flags & NDR_SET_VALUES) {
26737                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26738         }
26739         if (flags & NDR_IN) {
26740                 ndr_print_struct(ndr, "in", "spoolss_57");
26741                 ndr->depth++;
26742                 ndr->depth--;
26743         }
26744         if (flags & NDR_OUT) {
26745                 ndr_print_struct(ndr, "out", "spoolss_57");
26746                 ndr->depth++;
26747                 ndr_print_WERROR(ndr, "result", r->out.result);
26748                 ndr->depth--;
26749         }
26750         ndr->depth--;
26751 }
26752
26753 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26754 {
26755         if (flags & NDR_IN) {
26756                 if (r->in.handle == NULL) {
26757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26758                 }
26759                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26763                 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));
26764                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26767                 if (r->in.status_code == NULL) {
26768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26769                 }
26770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26771         }
26772         if (flags & NDR_OUT) {
26773                 if (r->out.out_data == NULL) {
26774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26775                 }
26776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26777                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26778                 if (r->out.needed == NULL) {
26779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26780                 }
26781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26782                 if (r->out.status_code == NULL) {
26783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26784                 }
26785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26787         }
26788         return NDR_ERR_SUCCESS;
26789 }
26790
26791 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26792 {
26793         TALLOC_CTX *_mem_save_handle_0;
26794         TALLOC_CTX *_mem_save_needed_0;
26795         TALLOC_CTX *_mem_save_status_code_0;
26796         if (flags & NDR_IN) {
26797                 ZERO_STRUCT(r->out);
26798
26799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26800                         NDR_PULL_ALLOC(ndr, r->in.handle);
26801                 }
26802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26806                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26807                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26808                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26809                         return 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));
26810                 }
26811                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26812                 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));
26813                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26817                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26818                 }
26819                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26820                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26823                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26824                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26825                 NDR_PULL_ALLOC(ndr, r->out.needed);
26826                 ZERO_STRUCTP(r->out.needed);
26827                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26828                 *r->out.status_code = *r->in.status_code;
26829         }
26830         if (flags & NDR_OUT) {
26831                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26832                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26833                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26834                 }
26835                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26836                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26837                         NDR_PULL_ALLOC(ndr, r->out.needed);
26838                 }
26839                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26840                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26844                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26845                 }
26846                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26850                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26851                 if (r->out.out_data) {
26852                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26853                 }
26854         }
26855         return NDR_ERR_SUCCESS;
26856 }
26857
26858 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26859 {
26860         ndr_print_struct(ndr, name, "spoolss_XcvData");
26861         ndr->depth++;
26862         if (flags & NDR_SET_VALUES) {
26863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26864         }
26865         if (flags & NDR_IN) {
26866                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26867                 ndr->depth++;
26868                 ndr_print_ptr(ndr, "handle", r->in.handle);
26869                 ndr->depth++;
26870                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26871                 ndr->depth--;
26872                 ndr_print_string(ndr, "function_name", r->in.function_name);
26873                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26874                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26875                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26876                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26877                 ndr->depth++;
26878                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26879                 ndr->depth--;
26880                 ndr->depth--;
26881         }
26882         if (flags & NDR_OUT) {
26883                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26884                 ndr->depth++;
26885                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26886                 ndr->depth++;
26887                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26888                 ndr->depth--;
26889                 ndr_print_ptr(ndr, "needed", r->out.needed);
26890                 ndr->depth++;
26891                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26892                 ndr->depth--;
26893                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26894                 ndr->depth++;
26895                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26896                 ndr->depth--;
26897                 ndr_print_WERROR(ndr, "result", r->out.result);
26898                 ndr->depth--;
26899         }
26900         ndr->depth--;
26901 }
26902
26903 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26904 {
26905         if (flags & NDR_IN) {
26906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26907                 if (r->in.servername) {
26908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26911                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26912                 }
26913                 if (r->in.info_ctr == NULL) {
26914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26915                 }
26916                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26917                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26918         }
26919         if (flags & NDR_OUT) {
26920                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26921         }
26922         return NDR_ERR_SUCCESS;
26923 }
26924
26925 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26926 {
26927         uint32_t _ptr_servername;
26928         TALLOC_CTX *_mem_save_servername_0;
26929         TALLOC_CTX *_mem_save_info_ctr_0;
26930         if (flags & NDR_IN) {
26931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26932                 if (_ptr_servername) {
26933                         NDR_PULL_ALLOC(ndr, r->in.servername);
26934                 } else {
26935                         r->in.servername = NULL;
26936                 }
26937                 if (r->in.servername) {
26938                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26942                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26943                                 return 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));
26944                         }
26945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26948                 }
26949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26950                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26951                 }
26952                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26953                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26954                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26956                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
26957         }
26958         if (flags & NDR_OUT) {
26959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26960         }
26961         return NDR_ERR_SUCCESS;
26962 }
26963
26964 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
26965 {
26966         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
26967         ndr->depth++;
26968         if (flags & NDR_SET_VALUES) {
26969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26970         }
26971         if (flags & NDR_IN) {
26972                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
26973                 ndr->depth++;
26974                 ndr_print_ptr(ndr, "servername", r->in.servername);
26975                 ndr->depth++;
26976                 if (r->in.servername) {
26977                         ndr_print_string(ndr, "servername", r->in.servername);
26978                 }
26979                 ndr->depth--;
26980                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26981                 ndr->depth++;
26982                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26983                 ndr->depth--;
26984                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
26985                 ndr->depth--;
26986         }
26987         if (flags & NDR_OUT) {
26988                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
26989                 ndr->depth++;
26990                 ndr_print_WERROR(ndr, "result", r->out.result);
26991                 ndr->depth--;
26992         }
26993         ndr->depth--;
26994 }
26995
26996 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
26997 {
26998         if (flags & NDR_IN) {
26999         }
27000         if (flags & NDR_OUT) {
27001                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27002         }
27003         return NDR_ERR_SUCCESS;
27004 }
27005
27006 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27007 {
27008         if (flags & NDR_IN) {
27009         }
27010         if (flags & NDR_OUT) {
27011                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27012         }
27013         return NDR_ERR_SUCCESS;
27014 }
27015
27016 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27017 {
27018         ndr_print_struct(ndr, name, "spoolss_5a");
27019         ndr->depth++;
27020         if (flags & NDR_SET_VALUES) {
27021                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27022         }
27023         if (flags & NDR_IN) {
27024                 ndr_print_struct(ndr, "in", "spoolss_5a");
27025                 ndr->depth++;
27026                 ndr->depth--;
27027         }
27028         if (flags & NDR_OUT) {
27029                 ndr_print_struct(ndr, "out", "spoolss_5a");
27030                 ndr->depth++;
27031                 ndr_print_WERROR(ndr, "result", r->out.result);
27032                 ndr->depth--;
27033         }
27034         ndr->depth--;
27035 }
27036
27037 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27038 {
27039         if (flags & NDR_IN) {
27040         }
27041         if (flags & NDR_OUT) {
27042                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27043         }
27044         return NDR_ERR_SUCCESS;
27045 }
27046
27047 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27048 {
27049         if (flags & NDR_IN) {
27050         }
27051         if (flags & NDR_OUT) {
27052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27053         }
27054         return NDR_ERR_SUCCESS;
27055 }
27056
27057 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27058 {
27059         ndr_print_struct(ndr, name, "spoolss_5b");
27060         ndr->depth++;
27061         if (flags & NDR_SET_VALUES) {
27062                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27063         }
27064         if (flags & NDR_IN) {
27065                 ndr_print_struct(ndr, "in", "spoolss_5b");
27066                 ndr->depth++;
27067                 ndr->depth--;
27068         }
27069         if (flags & NDR_OUT) {
27070                 ndr_print_struct(ndr, "out", "spoolss_5b");
27071                 ndr->depth++;
27072                 ndr_print_WERROR(ndr, "result", r->out.result);
27073                 ndr->depth--;
27074         }
27075         ndr->depth--;
27076 }
27077
27078 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27079 {
27080         if (flags & NDR_IN) {
27081         }
27082         if (flags & NDR_OUT) {
27083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27084         }
27085         return NDR_ERR_SUCCESS;
27086 }
27087
27088 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27089 {
27090         if (flags & NDR_IN) {
27091         }
27092         if (flags & NDR_OUT) {
27093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27094         }
27095         return NDR_ERR_SUCCESS;
27096 }
27097
27098 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27099 {
27100         ndr_print_struct(ndr, name, "spoolss_5c");
27101         ndr->depth++;
27102         if (flags & NDR_SET_VALUES) {
27103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27104         }
27105         if (flags & NDR_IN) {
27106                 ndr_print_struct(ndr, "in", "spoolss_5c");
27107                 ndr->depth++;
27108                 ndr->depth--;
27109         }
27110         if (flags & NDR_OUT) {
27111                 ndr_print_struct(ndr, "out", "spoolss_5c");
27112                 ndr->depth++;
27113                 ndr_print_WERROR(ndr, "result", r->out.result);
27114                 ndr->depth--;
27115         }
27116         ndr->depth--;
27117 }
27118
27119 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27120 {
27121         if (flags & NDR_IN) {
27122         }
27123         if (flags & NDR_OUT) {
27124                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27125         }
27126         return NDR_ERR_SUCCESS;
27127 }
27128
27129 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27130 {
27131         if (flags & NDR_IN) {
27132         }
27133         if (flags & NDR_OUT) {
27134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27135         }
27136         return NDR_ERR_SUCCESS;
27137 }
27138
27139 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27140 {
27141         ndr_print_struct(ndr, name, "spoolss_5d");
27142         ndr->depth++;
27143         if (flags & NDR_SET_VALUES) {
27144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27145         }
27146         if (flags & NDR_IN) {
27147                 ndr_print_struct(ndr, "in", "spoolss_5d");
27148                 ndr->depth++;
27149                 ndr->depth--;
27150         }
27151         if (flags & NDR_OUT) {
27152                 ndr_print_struct(ndr, "out", "spoolss_5d");
27153                 ndr->depth++;
27154                 ndr_print_WERROR(ndr, "result", r->out.result);
27155                 ndr->depth--;
27156         }
27157         ndr->depth--;
27158 }
27159
27160 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27161 {
27162         if (flags & NDR_IN) {
27163         }
27164         if (flags & NDR_OUT) {
27165                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27166         }
27167         return NDR_ERR_SUCCESS;
27168 }
27169
27170 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27171 {
27172         if (flags & NDR_IN) {
27173         }
27174         if (flags & NDR_OUT) {
27175                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27176         }
27177         return NDR_ERR_SUCCESS;
27178 }
27179
27180 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27181 {
27182         ndr_print_struct(ndr, name, "spoolss_5e");
27183         ndr->depth++;
27184         if (flags & NDR_SET_VALUES) {
27185                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27186         }
27187         if (flags & NDR_IN) {
27188                 ndr_print_struct(ndr, "in", "spoolss_5e");
27189                 ndr->depth++;
27190                 ndr->depth--;
27191         }
27192         if (flags & NDR_OUT) {
27193                 ndr_print_struct(ndr, "out", "spoolss_5e");
27194                 ndr->depth++;
27195                 ndr_print_WERROR(ndr, "result", r->out.result);
27196                 ndr->depth--;
27197         }
27198         ndr->depth--;
27199 }
27200
27201 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27202 {
27203         if (flags & NDR_IN) {
27204         }
27205         if (flags & NDR_OUT) {
27206                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27207         }
27208         return NDR_ERR_SUCCESS;
27209 }
27210
27211 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27212 {
27213         if (flags & NDR_IN) {
27214         }
27215         if (flags & NDR_OUT) {
27216                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27217         }
27218         return NDR_ERR_SUCCESS;
27219 }
27220
27221 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27222 {
27223         ndr_print_struct(ndr, name, "spoolss_5f");
27224         ndr->depth++;
27225         if (flags & NDR_SET_VALUES) {
27226                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27227         }
27228         if (flags & NDR_IN) {
27229                 ndr_print_struct(ndr, "in", "spoolss_5f");
27230                 ndr->depth++;
27231                 ndr->depth--;
27232         }
27233         if (flags & NDR_OUT) {
27234                 ndr_print_struct(ndr, "out", "spoolss_5f");
27235                 ndr->depth++;
27236                 ndr_print_WERROR(ndr, "result", r->out.result);
27237                 ndr->depth--;
27238         }
27239         ndr->depth--;
27240 }
27241
27242 static const struct ndr_interface_call spoolss_calls[] = {
27243         {
27244                 "spoolss_EnumPrinters",
27245                 sizeof(struct spoolss_EnumPrinters),
27246                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27248                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27249                 false,
27250         },
27251         {
27252                 "spoolss_OpenPrinter",
27253                 sizeof(struct spoolss_OpenPrinter),
27254                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27256                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27257                 false,
27258         },
27259         {
27260                 "spoolss_SetJob",
27261                 sizeof(struct spoolss_SetJob),
27262                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27264                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27265                 false,
27266         },
27267         {
27268                 "spoolss_GetJob",
27269                 sizeof(struct spoolss_GetJob),
27270                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27272                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27273                 false,
27274         },
27275         {
27276                 "spoolss_EnumJobs",
27277                 sizeof(struct spoolss_EnumJobs),
27278                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27280                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27281                 false,
27282         },
27283         {
27284                 "spoolss_AddPrinter",
27285                 sizeof(struct spoolss_AddPrinter),
27286                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27288                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27289                 false,
27290         },
27291         {
27292                 "spoolss_DeletePrinter",
27293                 sizeof(struct spoolss_DeletePrinter),
27294                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27296                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27297                 false,
27298         },
27299         {
27300                 "spoolss_SetPrinter",
27301                 sizeof(struct spoolss_SetPrinter),
27302                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27304                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27305                 false,
27306         },
27307         {
27308                 "spoolss_GetPrinter",
27309                 sizeof(struct spoolss_GetPrinter),
27310                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27312                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27313                 false,
27314         },
27315         {
27316                 "spoolss_AddPrinterDriver",
27317                 sizeof(struct spoolss_AddPrinterDriver),
27318                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27320                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27321                 false,
27322         },
27323         {
27324                 "spoolss_EnumPrinterDrivers",
27325                 sizeof(struct spoolss_EnumPrinterDrivers),
27326                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27328                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27329                 false,
27330         },
27331         {
27332                 "spoolss_GetPrinterDriver",
27333                 sizeof(struct spoolss_GetPrinterDriver),
27334                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27336                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27337                 false,
27338         },
27339         {
27340                 "spoolss_GetPrinterDriverDirectory",
27341                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27342                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27344                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27345                 false,
27346         },
27347         {
27348                 "spoolss_DeletePrinterDriver",
27349                 sizeof(struct spoolss_DeletePrinterDriver),
27350                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27352                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27353                 false,
27354         },
27355         {
27356                 "spoolss_AddPrintProcessor",
27357                 sizeof(struct spoolss_AddPrintProcessor),
27358                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27360                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27361                 false,
27362         },
27363         {
27364                 "spoolss_EnumPrintProcessors",
27365                 sizeof(struct spoolss_EnumPrintProcessors),
27366                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27368                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27369                 false,
27370         },
27371         {
27372                 "spoolss_GetPrintProcessorDirectory",
27373                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27374                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27376                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27377                 false,
27378         },
27379         {
27380                 "spoolss_StartDocPrinter",
27381                 sizeof(struct spoolss_StartDocPrinter),
27382                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27384                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27385                 false,
27386         },
27387         {
27388                 "spoolss_StartPagePrinter",
27389                 sizeof(struct spoolss_StartPagePrinter),
27390                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27392                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27393                 false,
27394         },
27395         {
27396                 "spoolss_WritePrinter",
27397                 sizeof(struct spoolss_WritePrinter),
27398                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27400                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27401                 false,
27402         },
27403         {
27404                 "spoolss_EndPagePrinter",
27405                 sizeof(struct spoolss_EndPagePrinter),
27406                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27408                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27409                 false,
27410         },
27411         {
27412                 "spoolss_AbortPrinter",
27413                 sizeof(struct spoolss_AbortPrinter),
27414                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27416                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27417                 false,
27418         },
27419         {
27420                 "spoolss_ReadPrinter",
27421                 sizeof(struct spoolss_ReadPrinter),
27422                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27424                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27425                 false,
27426         },
27427         {
27428                 "spoolss_EndDocPrinter",
27429                 sizeof(struct spoolss_EndDocPrinter),
27430                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27431                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27432                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27433                 false,
27434         },
27435         {
27436                 "spoolss_AddJob",
27437                 sizeof(struct spoolss_AddJob),
27438                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27439                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27440                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27441                 false,
27442         },
27443         {
27444                 "spoolss_ScheduleJob",
27445                 sizeof(struct spoolss_ScheduleJob),
27446                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27447                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27448                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27449                 false,
27450         },
27451         {
27452                 "spoolss_GetPrinterData",
27453                 sizeof(struct spoolss_GetPrinterData),
27454                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27455                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27456                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27457                 false,
27458         },
27459         {
27460                 "spoolss_SetPrinterData",
27461                 sizeof(struct spoolss_SetPrinterData),
27462                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27463                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27464                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27465                 false,
27466         },
27467         {
27468                 "spoolss_WaitForPrinterChange",
27469                 sizeof(struct spoolss_WaitForPrinterChange),
27470                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27471                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27472                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27473                 false,
27474         },
27475         {
27476                 "spoolss_ClosePrinter",
27477                 sizeof(struct spoolss_ClosePrinter),
27478                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27479                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27480                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27481                 false,
27482         },
27483         {
27484                 "spoolss_AddForm",
27485                 sizeof(struct spoolss_AddForm),
27486                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27487                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27488                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27489                 false,
27490         },
27491         {
27492                 "spoolss_DeleteForm",
27493                 sizeof(struct spoolss_DeleteForm),
27494                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27495                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27496                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27497                 false,
27498         },
27499         {
27500                 "spoolss_GetForm",
27501                 sizeof(struct spoolss_GetForm),
27502                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27503                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27504                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27505                 false,
27506         },
27507         {
27508                 "spoolss_SetForm",
27509                 sizeof(struct spoolss_SetForm),
27510                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27511                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27512                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27513                 false,
27514         },
27515         {
27516                 "spoolss_EnumForms",
27517                 sizeof(struct spoolss_EnumForms),
27518                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27519                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27520                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27521                 false,
27522         },
27523         {
27524                 "spoolss_EnumPorts",
27525                 sizeof(struct spoolss_EnumPorts),
27526                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27527                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27528                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27529                 false,
27530         },
27531         {
27532                 "spoolss_EnumMonitors",
27533                 sizeof(struct spoolss_EnumMonitors),
27534                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27535                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27536                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27537                 false,
27538         },
27539         {
27540                 "spoolss_AddPort",
27541                 sizeof(struct spoolss_AddPort),
27542                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27543                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27544                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27545                 false,
27546         },
27547         {
27548                 "spoolss_ConfigurePort",
27549                 sizeof(struct spoolss_ConfigurePort),
27550                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27551                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27552                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27553                 false,
27554         },
27555         {
27556                 "spoolss_DeletePort",
27557                 sizeof(struct spoolss_DeletePort),
27558                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27559                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27560                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27561                 false,
27562         },
27563         {
27564                 "spoolss_CreatePrinterIC",
27565                 sizeof(struct spoolss_CreatePrinterIC),
27566                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27567                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27568                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27569                 false,
27570         },
27571         {
27572                 "spoolss_PlayGDIScriptOnPrinterIC",
27573                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27574                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27575                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27576                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27577                 false,
27578         },
27579         {
27580                 "spoolss_DeletePrinterIC",
27581                 sizeof(struct spoolss_DeletePrinterIC),
27582                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27583                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27584                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27585                 false,
27586         },
27587         {
27588                 "spoolss_AddPrinterConnection",
27589                 sizeof(struct spoolss_AddPrinterConnection),
27590                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27591                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27592                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27593                 false,
27594         },
27595         {
27596                 "spoolss_DeletePrinterConnection",
27597                 sizeof(struct spoolss_DeletePrinterConnection),
27598                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27599                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27600                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27601                 false,
27602         },
27603         {
27604                 "spoolss_PrinterMessageBox",
27605                 sizeof(struct spoolss_PrinterMessageBox),
27606                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27607                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27608                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27609                 false,
27610         },
27611         {
27612                 "spoolss_AddMonitor",
27613                 sizeof(struct spoolss_AddMonitor),
27614                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27615                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27616                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27617                 false,
27618         },
27619         {
27620                 "spoolss_DeleteMonitor",
27621                 sizeof(struct spoolss_DeleteMonitor),
27622                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27623                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27624                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27625                 false,
27626         },
27627         {
27628                 "spoolss_DeletePrintProcessor",
27629                 sizeof(struct spoolss_DeletePrintProcessor),
27630                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27631                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27632                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27633                 false,
27634         },
27635         {
27636                 "spoolss_AddPrintProvidor",
27637                 sizeof(struct spoolss_AddPrintProvidor),
27638                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27639                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27640                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27641                 false,
27642         },
27643         {
27644                 "spoolss_DeletePrintProvidor",
27645                 sizeof(struct spoolss_DeletePrintProvidor),
27646                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27647                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27648                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27649                 false,
27650         },
27651         {
27652                 "spoolss_EnumPrintProcDataTypes",
27653                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27654                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27655                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27656                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27657                 false,
27658         },
27659         {
27660                 "spoolss_ResetPrinter",
27661                 sizeof(struct spoolss_ResetPrinter),
27662                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27664                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27665                 false,
27666         },
27667         {
27668                 "spoolss_GetPrinterDriver2",
27669                 sizeof(struct spoolss_GetPrinterDriver2),
27670                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27672                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27673                 false,
27674         },
27675         {
27676                 "spoolss_FindFirstPrinterChangeNotification",
27677                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27678                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27680                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27681                 false,
27682         },
27683         {
27684                 "spoolss_FindNextPrinterChangeNotification",
27685                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27686                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27688                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27689                 false,
27690         },
27691         {
27692                 "spoolss_FindClosePrinterNotify",
27693                 sizeof(struct spoolss_FindClosePrinterNotify),
27694                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27696                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27697                 false,
27698         },
27699         {
27700                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27701                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27702                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27704                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27705                 false,
27706         },
27707         {
27708                 "spoolss_ReplyOpenPrinter",
27709                 sizeof(struct spoolss_ReplyOpenPrinter),
27710                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27712                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27713                 false,
27714         },
27715         {
27716                 "spoolss_RouterReplyPrinter",
27717                 sizeof(struct spoolss_RouterReplyPrinter),
27718                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27720                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27721                 false,
27722         },
27723         {
27724                 "spoolss_ReplyClosePrinter",
27725                 sizeof(struct spoolss_ReplyClosePrinter),
27726                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27728                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27729                 false,
27730         },
27731         {
27732                 "spoolss_AddPortEx",
27733                 sizeof(struct spoolss_AddPortEx),
27734                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27736                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27737                 false,
27738         },
27739         {
27740                 "spoolss_RouterFindFirstPrinterChangeNotification",
27741                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27742                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27744                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27745                 false,
27746         },
27747         {
27748                 "spoolss_SpoolerInit",
27749                 sizeof(struct spoolss_SpoolerInit),
27750                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27752                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27753                 false,
27754         },
27755         {
27756                 "spoolss_ResetPrinterEx",
27757                 sizeof(struct spoolss_ResetPrinterEx),
27758                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27760                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27761                 false,
27762         },
27763         {
27764                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27765                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27766                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27768                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27769                 false,
27770         },
27771         {
27772                 "spoolss_RouterReplyPrinterEx",
27773                 sizeof(struct spoolss_RouterReplyPrinterEx),
27774                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27776                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27777                 false,
27778         },
27779         {
27780                 "spoolss_RouterRefreshPrinterChangeNotify",
27781                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27782                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27784                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27785                 false,
27786         },
27787         {
27788                 "spoolss_44",
27789                 sizeof(struct spoolss_44),
27790                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27792                 (ndr_print_function_t) ndr_print_spoolss_44,
27793                 false,
27794         },
27795         {
27796                 "spoolss_OpenPrinterEx",
27797                 sizeof(struct spoolss_OpenPrinterEx),
27798                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27800                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27801                 false,
27802         },
27803         {
27804                 "spoolss_AddPrinterEx",
27805                 sizeof(struct spoolss_AddPrinterEx),
27806                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27808                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27809                 false,
27810         },
27811         {
27812                 "spoolss_47",
27813                 sizeof(struct spoolss_47),
27814                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27816                 (ndr_print_function_t) ndr_print_spoolss_47,
27817                 false,
27818         },
27819         {
27820                 "spoolss_EnumPrinterData",
27821                 sizeof(struct spoolss_EnumPrinterData),
27822                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27824                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27825                 false,
27826         },
27827         {
27828                 "spoolss_DeletePrinterData",
27829                 sizeof(struct spoolss_DeletePrinterData),
27830                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27832                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27833                 false,
27834         },
27835         {
27836                 "spoolss_4a",
27837                 sizeof(struct spoolss_4a),
27838                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27840                 (ndr_print_function_t) ndr_print_spoolss_4a,
27841                 false,
27842         },
27843         {
27844                 "spoolss_4b",
27845                 sizeof(struct spoolss_4b),
27846                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27848                 (ndr_print_function_t) ndr_print_spoolss_4b,
27849                 false,
27850         },
27851         {
27852                 "spoolss_4c",
27853                 sizeof(struct spoolss_4c),
27854                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27856                 (ndr_print_function_t) ndr_print_spoolss_4c,
27857                 false,
27858         },
27859         {
27860                 "spoolss_SetPrinterDataEx",
27861                 sizeof(struct spoolss_SetPrinterDataEx),
27862                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27864                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27865                 false,
27866         },
27867         {
27868                 "spoolss_GetPrinterDataEx",
27869                 sizeof(struct spoolss_GetPrinterDataEx),
27870                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27872                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27873                 false,
27874         },
27875         {
27876                 "spoolss_EnumPrinterDataEx",
27877                 sizeof(struct spoolss_EnumPrinterDataEx),
27878                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27880                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27881                 false,
27882         },
27883         {
27884                 "spoolss_EnumPrinterKey",
27885                 sizeof(struct spoolss_EnumPrinterKey),
27886                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27888                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27889                 false,
27890         },
27891         {
27892                 "spoolss_DeletePrinterDataEx",
27893                 sizeof(struct spoolss_DeletePrinterDataEx),
27894                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27896                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27897                 false,
27898         },
27899         {
27900                 "spoolss_DeletePrinterKey",
27901                 sizeof(struct spoolss_DeletePrinterKey),
27902                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27904                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27905                 false,
27906         },
27907         {
27908                 "spoolss_53",
27909                 sizeof(struct spoolss_53),
27910                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27912                 (ndr_print_function_t) ndr_print_spoolss_53,
27913                 false,
27914         },
27915         {
27916                 "spoolss_DeletePrinterDriverEx",
27917                 sizeof(struct spoolss_DeletePrinterDriverEx),
27918                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27920                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27921                 false,
27922         },
27923         {
27924                 "spoolss_55",
27925                 sizeof(struct spoolss_55),
27926                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27928                 (ndr_print_function_t) ndr_print_spoolss_55,
27929                 false,
27930         },
27931         {
27932                 "spoolss_56",
27933                 sizeof(struct spoolss_56),
27934                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27936                 (ndr_print_function_t) ndr_print_spoolss_56,
27937                 false,
27938         },
27939         {
27940                 "spoolss_57",
27941                 sizeof(struct spoolss_57),
27942                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27944                 (ndr_print_function_t) ndr_print_spoolss_57,
27945                 false,
27946         },
27947         {
27948                 "spoolss_XcvData",
27949                 sizeof(struct spoolss_XcvData),
27950                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27952                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27953                 false,
27954         },
27955         {
27956                 "spoolss_AddPrinterDriverEx",
27957                 sizeof(struct spoolss_AddPrinterDriverEx),
27958                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
27959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
27960                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
27961                 false,
27962         },
27963         {
27964                 "spoolss_5a",
27965                 sizeof(struct spoolss_5a),
27966                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
27967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
27968                 (ndr_print_function_t) ndr_print_spoolss_5a,
27969                 false,
27970         },
27971         {
27972                 "spoolss_5b",
27973                 sizeof(struct spoolss_5b),
27974                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
27975                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
27976                 (ndr_print_function_t) ndr_print_spoolss_5b,
27977                 false,
27978         },
27979         {
27980                 "spoolss_5c",
27981                 sizeof(struct spoolss_5c),
27982                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
27983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
27984                 (ndr_print_function_t) ndr_print_spoolss_5c,
27985                 false,
27986         },
27987         {
27988                 "spoolss_5d",
27989                 sizeof(struct spoolss_5d),
27990                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
27991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
27992                 (ndr_print_function_t) ndr_print_spoolss_5d,
27993                 false,
27994         },
27995         {
27996                 "spoolss_5e",
27997                 sizeof(struct spoolss_5e),
27998                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
27999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28000                 (ndr_print_function_t) ndr_print_spoolss_5e,
28001                 false,
28002         },
28003         {
28004                 "spoolss_5f",
28005                 sizeof(struct spoolss_5f),
28006                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28008                 (ndr_print_function_t) ndr_print_spoolss_5f,
28009                 false,
28010         },
28011         { NULL, 0, NULL, NULL, NULL, false }
28012 };
28013
28014 static const char * const spoolss_endpoint_strings[] = {
28015         "ncacn_np:[\\pipe\\spoolss]",
28016 };
28017
28018 static const struct ndr_interface_string_array spoolss_endpoints = {
28019         .count  = 1,
28020         .names  = spoolss_endpoint_strings
28021 };
28022
28023 static const char * const spoolss_authservice_strings[] = {
28024         "host",
28025 };
28026
28027 static const struct ndr_interface_string_array spoolss_authservices = {
28028         .count  = 1,
28029         .names  = spoolss_authservice_strings
28030 };
28031
28032
28033 const struct ndr_interface_table ndr_table_spoolss = {
28034         .name           = "spoolss",
28035         .syntax_id      = {
28036                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28037                 NDR_SPOOLSS_VERSION
28038         },
28039         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28040         .num_calls      = 96,
28041         .calls          = spoolss_calls,
28042         .endpoints      = &spoolss_endpoints,
28043         .authservices   = &spoolss_authservices
28044 };
28045