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 _PUBLIC_ 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 _PUBLIC_ 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 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 570 {
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_push_align(ndr, 4));
 573                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 578                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 607                 {
 608                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 610                         {
 611                                 struct ndr_push *_ndr_driverextra_data;
 612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 613                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 614                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 615                         }
 616                         ndr->flags = _flags_save_DATA_BLOB;
 617                 }
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 633                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 662                 {
 663                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 665                         {
 666                                 struct ndr_pull *_ndr_driverextra_data;
 667                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 668                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 669                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 670                         }
 671                         ndr->flags = _flags_save_DATA_BLOB;
 672                 }
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 680 {
 681         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 682         ndr->depth++;
 683         ndr_print_string(ndr, "devicename", r->devicename);
 684         ndr_print_uint16(ndr, "specversion", r->specversion);
 685         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 686         ndr_print_uint16(ndr, "size", r->size);
 687         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 688         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 689         ndr_print_uint16(ndr, "orientation", r->orientation);
 690         ndr_print_uint16(ndr, "papersize", r->papersize);
 691         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 692         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 693         ndr_print_uint16(ndr, "scale", r->scale);
 694         ndr_print_uint16(ndr, "copies", r->copies);
 695         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 696         ndr_print_uint16(ndr, "printquality", r->printquality);
 697         ndr_print_uint16(ndr, "color", r->color);
 698         ndr_print_uint16(ndr, "duplex", r->duplex);
 699         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 700         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 701         ndr_print_uint16(ndr, "collate", r->collate);
 702         ndr_print_string(ndr, "formname", r->formname);
 703         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 704         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 705         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 706         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 707         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 708         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 709         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 710         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 711         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 712         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 713         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 714         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 715         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 716         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 717         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 718         ndr->depth--;
 719 }
 720
 721 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 722 {
 723         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 724 }
 725
 726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 727 {
 728         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 733 {
 734         uint32_t v;
 735         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 736         *r = v;
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 741 {
 742         ndr_print_uint32(ndr, name, r);
 743         ndr->depth++;
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 763         ndr->depth--;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_push_align(ndr, 4));
 770                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 771                 {
 772                         uint32_t _flags_save_string = ndr->flags;
 773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 775                         ndr->flags = _flags_save_string;
 776                 }
 777                 {
 778                         uint32_t _flags_save_string = ndr->flags;
 779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 781                         ndr->flags = _flags_save_string;
 782                 }
 783                 {
 784                         uint32_t _flags_save_string = ndr->flags;
 785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 787                         ndr->flags = _flags_save_string;
 788                 }
 789         }
 790         if (ndr_flags & NDR_BUFFERS) {
 791                 {
 792                         uint32_t _flags_save_string = ndr->flags;
 793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 794                         if (r->name) {
 795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 797                         }
 798                         ndr->flags = _flags_save_string;
 799                 }
 800                 {
 801                         uint32_t _flags_save_string = ndr->flags;
 802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 803                         if (r->description) {
 804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 806                         }
 807                         ndr->flags = _flags_save_string;
 808                 }
 809                 {
 810                         uint32_t _flags_save_string = ndr->flags;
 811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 812                         if (r->comment) {
 813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 815                         }
 816                         ndr->flags = _flags_save_string;
 817                 }
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 823 {
 824         uint32_t _ptr_name;
 825         TALLOC_CTX *_mem_save_name_0;
 826         uint32_t _ptr_description;
 827         TALLOC_CTX *_mem_save_description_0;
 828         uint32_t _ptr_comment;
 829         TALLOC_CTX *_mem_save_comment_0;
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 4));
 832                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 837                         if (_ptr_name) {
 838                                 NDR_PULL_ALLOC(ndr, r->name);
 839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 840                         } else {
 841                                 r->name = NULL;
 842                         }
 843                         ndr->flags = _flags_save_string;
 844                 }
 845                 {
 846                         uint32_t _flags_save_string = ndr->flags;
 847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 849                         if (_ptr_description) {
 850                                 NDR_PULL_ALLOC(ndr, r->description);
 851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 852                         } else {
 853                                 r->description = NULL;
 854                         }
 855                         ndr->flags = _flags_save_string;
 856                 }
 857                 {
 858                         uint32_t _flags_save_string = ndr->flags;
 859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 861                         if (_ptr_comment) {
 862                                 NDR_PULL_ALLOC(ndr, r->comment);
 863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 864                         } else {
 865                                 r->comment = NULL;
 866                         }
 867                         ndr->flags = _flags_save_string;
 868                 }
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         if (r->name) {
 875                                 uint32_t _relative_save_offset;
 876                                 _relative_save_offset = ndr->offset;
 877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 878                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 879                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 882                                 ndr->offset = _relative_save_offset;
 883                         }
 884                         ndr->flags = _flags_save_string;
 885                 }
 886                 {
 887                         uint32_t _flags_save_string = ndr->flags;
 888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 889                         if (r->description) {
 890                                 uint32_t _relative_save_offset;
 891                                 _relative_save_offset = ndr->offset;
 892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 893                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 897                                 ndr->offset = _relative_save_offset;
 898                         }
 899                         ndr->flags = _flags_save_string;
 900                 }
 901                 {
 902                         uint32_t _flags_save_string = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 904                         if (r->comment) {
 905                                 uint32_t _relative_save_offset;
 906                                 _relative_save_offset = ndr->offset;
 907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 908                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 909                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 912                                 ndr->offset = _relative_save_offset;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 921 {
 922         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 923         ndr->depth++;
 924         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 925         ndr_print_ptr(ndr, "name", r->name);
 926         ndr->depth++;
 927         if (r->name) {
 928                 ndr_print_string(ndr, "name", r->name);
 929         }
 930         ndr->depth--;
 931         ndr_print_ptr(ndr, "description", r->description);
 932         ndr->depth++;
 933         if (r->description) {
 934                 ndr_print_string(ndr, "description", r->description);
 935         }
 936         ndr->depth--;
 937         ndr_print_ptr(ndr, "comment", r->comment);
 938         ndr->depth++;
 939         if (r->comment) {
 940                 ndr_print_string(ndr, "comment", r->comment);
 941         }
 942         ndr->depth--;
 943         ndr->depth--;
 944 }
 945
 946 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 947 {
 948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 949 }
 950
 951 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 952 {
 953         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 958 {
 959         uint32_t v;
 960         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 961         *r = v;
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 966 {
 967         ndr_print_uint32(ndr, name, r);
 968         ndr->depth++;
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 985         ndr->depth--;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 989 {
 990         if (ndr_flags & NDR_SCALARS) {
 991                 NDR_CHECK(ndr_push_align(ndr, 4));
 992                 {
 993                         uint32_t _flags_save_string = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1002                         ndr->flags = _flags_save_string;
1003                 }
1004                 {
1005                         uint32_t _flags_save_string = ndr->flags;
1006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1014                         ndr->flags = _flags_save_string;
1015                 }
1016                 {
1017                         uint32_t _flags_save_string = ndr->flags;
1018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1020                         ndr->flags = _flags_save_string;
1021                 }
1022                 {
1023                         uint32_t _flags_save_string = ndr->flags;
1024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1026                         ndr->flags = _flags_save_string;
1027                 }
1028                 {
1029                         uint32_t _flags_save_string = ndr->flags;
1030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1032                         ndr->flags = _flags_save_string;
1033                 }
1034                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1039                         ndr->flags = _flags_save_string;
1040                 }
1041                 {
1042                         uint32_t _flags_save_string = ndr->flags;
1043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1045                         ndr->flags = _flags_save_string;
1046                 }
1047                 {
1048                         uint32_t _flags_save_string = ndr->flags;
1049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1057                         ndr->flags = _flags_save_string;
1058                 }
1059                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1060                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1065                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1068         }
1069         if (ndr_flags & NDR_BUFFERS) {
1070                 {
1071                         uint32_t _flags_save_string = ndr->flags;
1072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1073                         if (r->servername) {
1074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1076                         }
1077                         ndr->flags = _flags_save_string;
1078                 }
1079                 {
1080                         uint32_t _flags_save_string = ndr->flags;
1081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1082                         if (r->printername) {
1083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         if (r->sharename) {
1092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1094                         }
1095                         ndr->flags = _flags_save_string;
1096                 }
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1100                         if (r->portname) {
1101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1103                         }
1104                         ndr->flags = _flags_save_string;
1105                 }
1106                 {
1107                         uint32_t _flags_save_string = ndr->flags;
1108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1109                         if (r->drivername) {
1110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->comment) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1121                         }
1122                         ndr->flags = _flags_save_string;
1123                 }
1124                 {
1125                         uint32_t _flags_save_string = ndr->flags;
1126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1127                         if (r->location) {
1128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1129                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1130                         }
1131                         ndr->flags = _flags_save_string;
1132                 }
1133                 if (r->devmode) {
1134                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1135                         {
1136                                 struct ndr_push *_ndr_devmode;
1137                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1138                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1139                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1140                         }
1141                 }
1142                 {
1143                         uint32_t _flags_save_string = ndr->flags;
1144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1145                         if (r->sepfile) {
1146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1148                         }
1149                         ndr->flags = _flags_save_string;
1150                 }
1151                 {
1152                         uint32_t _flags_save_string = ndr->flags;
1153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1154                         if (r->printprocessor) {
1155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         if (r->datatype) {
1164                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1165                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1166                         }
1167                         ndr->flags = _flags_save_string;
1168                 }
1169                 {
1170                         uint32_t _flags_save_string = ndr->flags;
1171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1172                         if (r->parameters) {
1173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1175                         }
1176                         ndr->flags = _flags_save_string;
1177                 }
1178                 if (r->secdesc) {
1179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1180                         {
1181                                 struct ndr_push *_ndr_secdesc;
1182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1183                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1185                         }
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1192 {
1193         uint32_t _ptr_servername;
1194         TALLOC_CTX *_mem_save_servername_0;
1195         uint32_t _ptr_printername;
1196         TALLOC_CTX *_mem_save_printername_0;
1197         uint32_t _ptr_sharename;
1198         TALLOC_CTX *_mem_save_sharename_0;
1199         uint32_t _ptr_portname;
1200         TALLOC_CTX *_mem_save_portname_0;
1201         uint32_t _ptr_drivername;
1202         TALLOC_CTX *_mem_save_drivername_0;
1203         uint32_t _ptr_comment;
1204         TALLOC_CTX *_mem_save_comment_0;
1205         uint32_t _ptr_location;
1206         TALLOC_CTX *_mem_save_location_0;
1207         uint32_t _ptr_devmode;
1208         TALLOC_CTX *_mem_save_devmode_0;
1209         uint32_t _ptr_sepfile;
1210         TALLOC_CTX *_mem_save_sepfile_0;
1211         uint32_t _ptr_printprocessor;
1212         TALLOC_CTX *_mem_save_printprocessor_0;
1213         uint32_t _ptr_datatype;
1214         TALLOC_CTX *_mem_save_datatype_0;
1215         uint32_t _ptr_parameters;
1216         TALLOC_CTX *_mem_save_parameters_0;
1217         uint32_t _ptr_secdesc;
1218         TALLOC_CTX *_mem_save_secdesc_0;
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 {
1222                         uint32_t _flags_save_string = ndr->flags;
1223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1225                         if (_ptr_servername) {
1226                                 NDR_PULL_ALLOC(ndr, r->servername);
1227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1228                         } else {
1229                                 r->servername = NULL;
1230                         }
1231                         ndr->flags = _flags_save_string;
1232                 }
1233                 {
1234                         uint32_t _flags_save_string = ndr->flags;
1235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1237                         if (_ptr_printername) {
1238                                 NDR_PULL_ALLOC(ndr, r->printername);
1239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1240                         } else {
1241                                 r->printername = NULL;
1242                         }
1243                         ndr->flags = _flags_save_string;
1244                 }
1245                 {
1246                         uint32_t _flags_save_string = ndr->flags;
1247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1249                         if (_ptr_sharename) {
1250                                 NDR_PULL_ALLOC(ndr, r->sharename);
1251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1252                         } else {
1253                                 r->sharename = NULL;
1254                         }
1255                         ndr->flags = _flags_save_string;
1256                 }
1257                 {
1258                         uint32_t _flags_save_string = ndr->flags;
1259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1261                         if (_ptr_portname) {
1262                                 NDR_PULL_ALLOC(ndr, r->portname);
1263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1264                         } else {
1265                                 r->portname = NULL;
1266                         }
1267                         ndr->flags = _flags_save_string;
1268                 }
1269                 {
1270                         uint32_t _flags_save_string = ndr->flags;
1271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1273                         if (_ptr_drivername) {
1274                                 NDR_PULL_ALLOC(ndr, r->drivername);
1275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1276                         } else {
1277                                 r->drivername = NULL;
1278                         }
1279                         ndr->flags = _flags_save_string;
1280                 }
1281                 {
1282                         uint32_t _flags_save_string = ndr->flags;
1283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1285                         if (_ptr_comment) {
1286                                 NDR_PULL_ALLOC(ndr, r->comment);
1287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1288                         } else {
1289                                 r->comment = NULL;
1290                         }
1291                         ndr->flags = _flags_save_string;
1292                 }
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1297                         if (_ptr_location) {
1298                                 NDR_PULL_ALLOC(ndr, r->location);
1299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1300                         } else {
1301                                 r->location = NULL;
1302                         }
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1306                 if (_ptr_devmode) {
1307                         NDR_PULL_ALLOC(ndr, r->devmode);
1308                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1309                 } else {
1310                         r->devmode = NULL;
1311                 }
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1316                         if (_ptr_sepfile) {
1317                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1319                         } else {
1320                                 r->sepfile = NULL;
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1328                         if (_ptr_printprocessor) {
1329                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1331                         } else {
1332                                 r->printprocessor = NULL;
1333                         }
1334                         ndr->flags = _flags_save_string;
1335                 }
1336                 {
1337                         uint32_t _flags_save_string = ndr->flags;
1338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1340                         if (_ptr_datatype) {
1341                                 NDR_PULL_ALLOC(ndr, r->datatype);
1342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1343                         } else {
1344                                 r->datatype = NULL;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1352                         if (_ptr_parameters) {
1353                                 NDR_PULL_ALLOC(ndr, r->parameters);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1355                         } else {
1356                                 r->parameters = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1361                 if (_ptr_secdesc) {
1362                         NDR_PULL_ALLOC(ndr, r->secdesc);
1363                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1364                 } else {
1365                         r->secdesc = NULL;
1366                 }
1367                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1372                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1375         }
1376         if (ndr_flags & NDR_BUFFERS) {
1377                 {
1378                         uint32_t _flags_save_string = ndr->flags;
1379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1380                         if (r->servername) {
1381                                 uint32_t _relative_save_offset;
1382                                 _relative_save_offset = ndr->offset;
1383                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1384                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1385                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1386                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1387                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1388                                 ndr->offset = _relative_save_offset;
1389                         }
1390                         ndr->flags = _flags_save_string;
1391                 }
1392                 {
1393                         uint32_t _flags_save_string = ndr->flags;
1394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1395                         if (r->printername) {
1396                                 uint32_t _relative_save_offset;
1397                                 _relative_save_offset = ndr->offset;
1398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1399                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1400                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1403                                 ndr->offset = _relative_save_offset;
1404                         }
1405                         ndr->flags = _flags_save_string;
1406                 }
1407                 {
1408                         uint32_t _flags_save_string = ndr->flags;
1409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1410                         if (r->sharename) {
1411                                 uint32_t _relative_save_offset;
1412                                 _relative_save_offset = ndr->offset;
1413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1414                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1415                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1418                                 ndr->offset = _relative_save_offset;
1419                         }
1420                         ndr->flags = _flags_save_string;
1421                 }
1422                 {
1423                         uint32_t _flags_save_string = ndr->flags;
1424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1425                         if (r->portname) {
1426                                 uint32_t _relative_save_offset;
1427                                 _relative_save_offset = ndr->offset;
1428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1429                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1430                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1433                                 ndr->offset = _relative_save_offset;
1434                         }
1435                         ndr->flags = _flags_save_string;
1436                 }
1437                 {
1438                         uint32_t _flags_save_string = ndr->flags;
1439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1440                         if (r->drivername) {
1441                                 uint32_t _relative_save_offset;
1442                                 _relative_save_offset = ndr->offset;
1443                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1444                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1445                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1446                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1447                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1448                                 ndr->offset = _relative_save_offset;
1449                         }
1450                         ndr->flags = _flags_save_string;
1451                 }
1452                 {
1453                         uint32_t _flags_save_string = ndr->flags;
1454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1455                         if (r->comment) {
1456                                 uint32_t _relative_save_offset;
1457                                 _relative_save_offset = ndr->offset;
1458                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1459                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1460                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1461                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1462                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1463                                 ndr->offset = _relative_save_offset;
1464                         }
1465                         ndr->flags = _flags_save_string;
1466                 }
1467                 {
1468                         uint32_t _flags_save_string = ndr->flags;
1469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1470                         if (r->location) {
1471                                 uint32_t _relative_save_offset;
1472                                 _relative_save_offset = ndr->offset;
1473                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1474                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1475                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1476                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1477                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1478                                 ndr->offset = _relative_save_offset;
1479                         }
1480                         ndr->flags = _flags_save_string;
1481                 }
1482                 if (r->devmode) {
1483                         uint32_t _relative_save_offset;
1484                         _relative_save_offset = ndr->offset;
1485                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1486                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1487                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1488                         {
1489                                 struct ndr_pull *_ndr_devmode;
1490                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1491                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1492                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1493                         }
1494                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1495                         ndr->offset = _relative_save_offset;
1496                 }
1497                 {
1498                         uint32_t _flags_save_string = ndr->flags;
1499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1500                         if (r->sepfile) {
1501                                 uint32_t _relative_save_offset;
1502                                 _relative_save_offset = ndr->offset;
1503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1504                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1505                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1508                                 ndr->offset = _relative_save_offset;
1509                         }
1510                         ndr->flags = _flags_save_string;
1511                 }
1512                 {
1513                         uint32_t _flags_save_string = ndr->flags;
1514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1515                         if (r->printprocessor) {
1516                                 uint32_t _relative_save_offset;
1517                                 _relative_save_offset = ndr->offset;
1518                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1519                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1520                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1521                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1522                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1523                                 ndr->offset = _relative_save_offset;
1524                         }
1525                         ndr->flags = _flags_save_string;
1526                 }
1527                 {
1528                         uint32_t _flags_save_string = ndr->flags;
1529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1530                         if (r->datatype) {
1531                                 uint32_t _relative_save_offset;
1532                                 _relative_save_offset = ndr->offset;
1533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1534                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1535                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1538                                 ndr->offset = _relative_save_offset;
1539                         }
1540                         ndr->flags = _flags_save_string;
1541                 }
1542                 {
1543                         uint32_t _flags_save_string = ndr->flags;
1544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1545                         if (r->parameters) {
1546                                 uint32_t _relative_save_offset;
1547                                 _relative_save_offset = ndr->offset;
1548                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1549                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1550                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1551                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1552                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1553                                 ndr->offset = _relative_save_offset;
1554                         }
1555                         ndr->flags = _flags_save_string;
1556                 }
1557                 if (r->secdesc) {
1558                         uint32_t _relative_save_offset;
1559                         _relative_save_offset = ndr->offset;
1560                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1561                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1562                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1563                         {
1564                                 struct ndr_pull *_ndr_secdesc;
1565                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1566                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1567                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1568                         }
1569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1570                         ndr->offset = _relative_save_offset;
1571                 }
1572         }
1573         return NDR_ERR_SUCCESS;
1574 }
1575
1576 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1577 {
1578         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1579         ndr->depth++;
1580         ndr_print_ptr(ndr, "servername", r->servername);
1581         ndr->depth++;
1582         if (r->servername) {
1583                 ndr_print_string(ndr, "servername", r->servername);
1584         }
1585         ndr->depth--;
1586         ndr_print_ptr(ndr, "printername", r->printername);
1587         ndr->depth++;
1588         if (r->printername) {
1589                 ndr_print_string(ndr, "printername", r->printername);
1590         }
1591         ndr->depth--;
1592         ndr_print_ptr(ndr, "sharename", r->sharename);
1593         ndr->depth++;
1594         if (r->sharename) {
1595                 ndr_print_string(ndr, "sharename", r->sharename);
1596         }
1597         ndr->depth--;
1598         ndr_print_ptr(ndr, "portname", r->portname);
1599         ndr->depth++;
1600         if (r->portname) {
1601                 ndr_print_string(ndr, "portname", r->portname);
1602         }
1603         ndr->depth--;
1604         ndr_print_ptr(ndr, "drivername", r->drivername);
1605         ndr->depth++;
1606         if (r->drivername) {
1607                 ndr_print_string(ndr, "drivername", r->drivername);
1608         }
1609         ndr->depth--;
1610         ndr_print_ptr(ndr, "comment", r->comment);
1611         ndr->depth++;
1612         if (r->comment) {
1613                 ndr_print_string(ndr, "comment", r->comment);
1614         }
1615         ndr->depth--;
1616         ndr_print_ptr(ndr, "location", r->location);
1617         ndr->depth++;
1618         if (r->location) {
1619                 ndr_print_string(ndr, "location", r->location);
1620         }
1621         ndr->depth--;
1622         ndr_print_ptr(ndr, "devmode", r->devmode);
1623         ndr->depth++;
1624         if (r->devmode) {
1625                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1626         }
1627         ndr->depth--;
1628         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1629         ndr->depth++;
1630         if (r->sepfile) {
1631                 ndr_print_string(ndr, "sepfile", r->sepfile);
1632         }
1633         ndr->depth--;
1634         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1635         ndr->depth++;
1636         if (r->printprocessor) {
1637                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1638         }
1639         ndr->depth--;
1640         ndr_print_ptr(ndr, "datatype", r->datatype);
1641         ndr->depth++;
1642         if (r->datatype) {
1643                 ndr_print_string(ndr, "datatype", r->datatype);
1644         }
1645         ndr->depth--;
1646         ndr_print_ptr(ndr, "parameters", r->parameters);
1647         ndr->depth++;
1648         if (r->parameters) {
1649                 ndr_print_string(ndr, "parameters", r->parameters);
1650         }
1651         ndr->depth--;
1652         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1653         ndr->depth++;
1654         if (r->secdesc) {
1655                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1656         }
1657         ndr->depth--;
1658         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1659         ndr_print_uint32(ndr, "priority", r->priority);
1660         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1661         ndr_print_uint32(ndr, "starttime", r->starttime);
1662         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1663         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1664         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1665         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1666         ndr->depth--;
1667 }
1668
1669 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1670 {
1671         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1672 }
1673
1674 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1675 {
1676         if (ndr_flags & NDR_SCALARS) {
1677                 NDR_CHECK(ndr_push_align(ndr, 4));
1678                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1679         }
1680         if (ndr_flags & NDR_BUFFERS) {
1681                 if (r->secdesc) {
1682                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1683                         {
1684                                 struct ndr_push *_ndr_secdesc;
1685                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1686                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1687                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1688                         }
1689                 }
1690         }
1691         return NDR_ERR_SUCCESS;
1692 }
1693
1694 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1695 {
1696         uint32_t _ptr_secdesc;
1697         TALLOC_CTX *_mem_save_secdesc_0;
1698         if (ndr_flags & NDR_SCALARS) {
1699                 NDR_CHECK(ndr_pull_align(ndr, 4));
1700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1701                 if (_ptr_secdesc) {
1702                         NDR_PULL_ALLOC(ndr, r->secdesc);
1703                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1704                 } else {
1705                         r->secdesc = NULL;
1706                 }
1707         }
1708         if (ndr_flags & NDR_BUFFERS) {
1709                 if (r->secdesc) {
1710                         uint32_t _relative_save_offset;
1711                         _relative_save_offset = ndr->offset;
1712                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1713                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1714                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1715                         {
1716                                 struct ndr_pull *_ndr_secdesc;
1717                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1718                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1719                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1720                         }
1721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1722                         ndr->offset = _relative_save_offset;
1723                 }
1724         }
1725         return NDR_ERR_SUCCESS;
1726 }
1727
1728 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1729 {
1730         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1731         ndr->depth++;
1732         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1733         ndr->depth++;
1734         if (r->secdesc) {
1735                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1736         }
1737         ndr->depth--;
1738         ndr->depth--;
1739 }
1740
1741 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1742 {
1743         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1744 }
1745
1746 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1747 {
1748         if (ndr_flags & NDR_SCALARS) {
1749                 NDR_CHECK(ndr_push_align(ndr, 4));
1750                 {
1751                         uint32_t _flags_save_string = ndr->flags;
1752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1753                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1754                         ndr->flags = _flags_save_string;
1755                 }
1756                 {
1757                         uint32_t _flags_save_string = ndr->flags;
1758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1760                         ndr->flags = _flags_save_string;
1761                 }
1762                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1763         }
1764         if (ndr_flags & NDR_BUFFERS) {
1765                 {
1766                         uint32_t _flags_save_string = ndr->flags;
1767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1768                         if (r->printername) {
1769                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1770                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1771                         }
1772                         ndr->flags = _flags_save_string;
1773                 }
1774                 {
1775                         uint32_t _flags_save_string = ndr->flags;
1776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1777                         if (r->servername) {
1778                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1779                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1780                         }
1781                         ndr->flags = _flags_save_string;
1782                 }
1783         }
1784         return NDR_ERR_SUCCESS;
1785 }
1786
1787 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1788 {
1789         uint32_t _ptr_printername;
1790         TALLOC_CTX *_mem_save_printername_0;
1791         uint32_t _ptr_servername;
1792         TALLOC_CTX *_mem_save_servername_0;
1793         if (ndr_flags & NDR_SCALARS) {
1794                 NDR_CHECK(ndr_pull_align(ndr, 4));
1795                 {
1796                         uint32_t _flags_save_string = ndr->flags;
1797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1798                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1799                         if (_ptr_printername) {
1800                                 NDR_PULL_ALLOC(ndr, r->printername);
1801                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1802                         } else {
1803                                 r->printername = NULL;
1804                         }
1805                         ndr->flags = _flags_save_string;
1806                 }
1807                 {
1808                         uint32_t _flags_save_string = ndr->flags;
1809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1811                         if (_ptr_servername) {
1812                                 NDR_PULL_ALLOC(ndr, r->servername);
1813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1814                         } else {
1815                                 r->servername = NULL;
1816                         }
1817                         ndr->flags = _flags_save_string;
1818                 }
1819                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1820         }
1821         if (ndr_flags & NDR_BUFFERS) {
1822                 {
1823                         uint32_t _flags_save_string = ndr->flags;
1824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1825                         if (r->printername) {
1826                                 uint32_t _relative_save_offset;
1827                                 _relative_save_offset = ndr->offset;
1828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1829                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1830                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1831                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1833                                 ndr->offset = _relative_save_offset;
1834                         }
1835                         ndr->flags = _flags_save_string;
1836                 }
1837                 {
1838                         uint32_t _flags_save_string = ndr->flags;
1839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1840                         if (r->servername) {
1841                                 uint32_t _relative_save_offset;
1842                                 _relative_save_offset = ndr->offset;
1843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1844                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1845                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1848                                 ndr->offset = _relative_save_offset;
1849                         }
1850                         ndr->flags = _flags_save_string;
1851                 }
1852         }
1853         return NDR_ERR_SUCCESS;
1854 }
1855
1856 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1857 {
1858         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1859         ndr->depth++;
1860         ndr_print_ptr(ndr, "printername", r->printername);
1861         ndr->depth++;
1862         if (r->printername) {
1863                 ndr_print_string(ndr, "printername", r->printername);
1864         }
1865         ndr->depth--;
1866         ndr_print_ptr(ndr, "servername", r->servername);
1867         ndr->depth++;
1868         if (r->servername) {
1869                 ndr_print_string(ndr, "servername", r->servername);
1870         }
1871         ndr->depth--;
1872         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1873         ndr->depth--;
1874 }
1875
1876 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1877 {
1878         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1879 }
1880
1881 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1882 {
1883         if (ndr_flags & NDR_SCALARS) {
1884                 NDR_CHECK(ndr_push_align(ndr, 4));
1885                 {
1886                         uint32_t _flags_save_string = ndr->flags;
1887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1889                         ndr->flags = _flags_save_string;
1890                 }
1891                 {
1892                         uint32_t _flags_save_string = ndr->flags;
1893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1894                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1895                         ndr->flags = _flags_save_string;
1896                 }
1897                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1900         }
1901         if (ndr_flags & NDR_BUFFERS) {
1902                 {
1903                         uint32_t _flags_save_string = ndr->flags;
1904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1905                         if (r->printername) {
1906                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1907                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1908                         }
1909                         ndr->flags = _flags_save_string;
1910                 }
1911                 {
1912                         uint32_t _flags_save_string = ndr->flags;
1913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1914                         if (r->portname) {
1915                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1916                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1917                         }
1918                         ndr->flags = _flags_save_string;
1919                 }
1920         }
1921         return NDR_ERR_SUCCESS;
1922 }
1923
1924 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1925 {
1926         uint32_t _ptr_printername;
1927         TALLOC_CTX *_mem_save_printername_0;
1928         uint32_t _ptr_portname;
1929         TALLOC_CTX *_mem_save_portname_0;
1930         if (ndr_flags & NDR_SCALARS) {
1931                 NDR_CHECK(ndr_pull_align(ndr, 4));
1932                 {
1933                         uint32_t _flags_save_string = ndr->flags;
1934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1936                         if (_ptr_printername) {
1937                                 NDR_PULL_ALLOC(ndr, r->printername);
1938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1939                         } else {
1940                                 r->printername = NULL;
1941                         }
1942                         ndr->flags = _flags_save_string;
1943                 }
1944                 {
1945                         uint32_t _flags_save_string = ndr->flags;
1946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1948                         if (_ptr_portname) {
1949                                 NDR_PULL_ALLOC(ndr, r->portname);
1950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1951                         } else {
1952                                 r->portname = NULL;
1953                         }
1954                         ndr->flags = _flags_save_string;
1955                 }
1956                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1959         }
1960         if (ndr_flags & NDR_BUFFERS) {
1961                 {
1962                         uint32_t _flags_save_string = ndr->flags;
1963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1964                         if (r->printername) {
1965                                 uint32_t _relative_save_offset;
1966                                 _relative_save_offset = ndr->offset;
1967                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1968                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1969                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1970                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1971                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1972                                 ndr->offset = _relative_save_offset;
1973                         }
1974                         ndr->flags = _flags_save_string;
1975                 }
1976                 {
1977                         uint32_t _flags_save_string = ndr->flags;
1978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1979                         if (r->portname) {
1980                                 uint32_t _relative_save_offset;
1981                                 _relative_save_offset = ndr->offset;
1982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1983                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1984                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1985                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1987                                 ndr->offset = _relative_save_offset;
1988                         }
1989                         ndr->flags = _flags_save_string;
1990                 }
1991         }
1992         return NDR_ERR_SUCCESS;
1993 }
1994
1995 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1996 {
1997         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1998         ndr->depth++;
1999         ndr_print_ptr(ndr, "printername", r->printername);
2000         ndr->depth++;
2001         if (r->printername) {
2002                 ndr_print_string(ndr, "printername", r->printername);
2003         }
2004         ndr->depth--;
2005         ndr_print_ptr(ndr, "portname", r->portname);
2006         ndr->depth++;
2007         if (r->portname) {
2008                 ndr_print_string(ndr, "portname", r->portname);
2009         }
2010         ndr->depth--;
2011         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2012         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2013         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2014         ndr->depth--;
2015 }
2016
2017 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2018 {
2019         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2020 }
2021
2022 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2023 {
2024         if (ndr_flags & NDR_SCALARS) {
2025                 NDR_CHECK(ndr_push_align(ndr, 4));
2026                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2027         }
2028         if (ndr_flags & NDR_BUFFERS) {
2029         }
2030         return NDR_ERR_SUCCESS;
2031 }
2032
2033 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_pull_align(ndr, 4));
2037                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2038         }
2039         if (ndr_flags & NDR_BUFFERS) {
2040         }
2041         return NDR_ERR_SUCCESS;
2042 }
2043
2044 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2045 {
2046         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2047         ndr->depth++;
2048         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2049         ndr->depth--;
2050 }
2051
2052 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2053 {
2054         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2055 }
2056
2057 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2058 {
2059         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2060         return NDR_ERR_SUCCESS;
2061 }
2062
2063 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2064 {
2065         uint32_t v;
2066         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2067         *r = v;
2068         return NDR_ERR_SUCCESS;
2069 }
2070
2071 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2072 {
2073         ndr_print_uint32(ndr, name, r);
2074         ndr->depth++;
2075         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2076         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2077         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2080         ndr->depth--;
2081 }
2082
2083 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2084 {
2085         if (ndr_flags & NDR_SCALARS) {
2086                 NDR_CHECK(ndr_push_align(ndr, 4));
2087                 {
2088                         uint32_t _flags_save_string = ndr->flags;
2089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2090                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2091                         ndr->flags = _flags_save_string;
2092                 }
2093                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2094         }
2095         if (ndr_flags & NDR_BUFFERS) {
2096                 {
2097                         uint32_t _flags_save_string = ndr->flags;
2098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2099                         if (r->guid) {
2100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2102                         }
2103                         ndr->flags = _flags_save_string;
2104                 }
2105         }
2106         return NDR_ERR_SUCCESS;
2107 }
2108
2109 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2110 {
2111         uint32_t _ptr_guid;
2112         TALLOC_CTX *_mem_save_guid_0;
2113         if (ndr_flags & NDR_SCALARS) {
2114                 NDR_CHECK(ndr_pull_align(ndr, 4));
2115                 {
2116                         uint32_t _flags_save_string = ndr->flags;
2117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2119                         if (_ptr_guid) {
2120                                 NDR_PULL_ALLOC(ndr, r->guid);
2121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2122                         } else {
2123                                 r->guid = NULL;
2124                         }
2125                         ndr->flags = _flags_save_string;
2126                 }
2127                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2128         }
2129         if (ndr_flags & NDR_BUFFERS) {
2130                 {
2131                         uint32_t _flags_save_string = ndr->flags;
2132                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2133                         if (r->guid) {
2134                                 uint32_t _relative_save_offset;
2135                                 _relative_save_offset = ndr->offset;
2136                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2137                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2138                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2139                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2140                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2141                                 ndr->offset = _relative_save_offset;
2142                         }
2143                         ndr->flags = _flags_save_string;
2144                 }
2145         }
2146         return NDR_ERR_SUCCESS;
2147 }
2148
2149 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2150 {
2151         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2152         ndr->depth++;
2153         ndr_print_ptr(ndr, "guid", r->guid);
2154         ndr->depth++;
2155         if (r->guid) {
2156                 ndr_print_string(ndr, "guid", r->guid);
2157         }
2158         ndr->depth--;
2159         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2160         ndr->depth--;
2161 }
2162
2163 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2164 {
2165         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2166 }
2167
2168 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2169 {
2170         if (ndr_flags & NDR_SCALARS) {
2171                 NDR_CHECK(ndr_push_align(ndr, 4));
2172                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2173         }
2174         if (ndr_flags & NDR_BUFFERS) {
2175                 if (r->devmode) {
2176                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2177                         {
2178                                 struct ndr_push *_ndr_devmode;
2179                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2180                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2181                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2182                         }
2183                 }
2184         }
2185         return NDR_ERR_SUCCESS;
2186 }
2187
2188 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2189 {
2190         uint32_t _ptr_devmode;
2191         TALLOC_CTX *_mem_save_devmode_0;
2192         if (ndr_flags & NDR_SCALARS) {
2193                 NDR_CHECK(ndr_pull_align(ndr, 4));
2194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2195                 if (_ptr_devmode) {
2196                         NDR_PULL_ALLOC(ndr, r->devmode);
2197                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2198                 } else {
2199                         r->devmode = NULL;
2200                 }
2201         }
2202         if (ndr_flags & NDR_BUFFERS) {
2203                 if (r->devmode) {
2204                         uint32_t _relative_save_offset;
2205                         _relative_save_offset = ndr->offset;
2206                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2207                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2208                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2209                         {
2210                                 struct ndr_pull *_ndr_devmode;
2211                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2212                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2213                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2214                         }
2215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2216                         ndr->offset = _relative_save_offset;
2217                 }
2218         }
2219         return NDR_ERR_SUCCESS;
2220 }
2221
2222 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2223 {
2224         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2225         ndr->depth++;
2226         ndr_print_ptr(ndr, "devmode", r->devmode);
2227         ndr->depth++;
2228         if (r->devmode) {
2229                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2230         }
2231         ndr->depth--;
2232         ndr->depth--;
2233 }
2234
2235 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2236 {
2237         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2238         if (ndr_flags & NDR_SCALARS) {
2239                 int level = ndr_push_get_switch_value(ndr, r);
2240                 switch (level) {
2241                         case 0: {
2242                                 NDR_CHECK(ndr_push_align(ndr, 4));
2243                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2244                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2245                         break; }
2246
2247                         case 1: {
2248                                 NDR_CHECK(ndr_push_align(ndr, 4));
2249                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2250                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2251                         break; }
2252
2253                         case 2: {
2254                                 NDR_CHECK(ndr_push_align(ndr, 4));
2255                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2256                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2257                         break; }
2258
2259                         case 3: {
2260                                 NDR_CHECK(ndr_push_align(ndr, 4));
2261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2262                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2263                         break; }
2264
2265                         case 4: {
2266                                 NDR_CHECK(ndr_push_align(ndr, 4));
2267                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2268                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2269                         break; }
2270
2271                         case 5: {
2272                                 NDR_CHECK(ndr_push_align(ndr, 4));
2273                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2274                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2275                         break; }
2276
2277                         case 6: {
2278                                 NDR_CHECK(ndr_push_align(ndr, 4));
2279                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2280                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2281                         break; }
2282
2283                         case 7: {
2284                                 NDR_CHECK(ndr_push_align(ndr, 4));
2285                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2286                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2287                         break; }
2288
2289                         case 8: {
2290                                 NDR_CHECK(ndr_push_align(ndr, 4));
2291                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2292                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2293                         break; }
2294
2295                         case 9: {
2296                                 NDR_CHECK(ndr_push_align(ndr, 4));
2297                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2298                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2299                         break; }
2300
2301                         default: {
2302                         break; }
2303
2304                 }
2305         }
2306         if (ndr_flags & NDR_BUFFERS) {
2307                 int level = ndr_push_get_switch_value(ndr, r);
2308                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2309                 switch (level) {
2310                         case 0:
2311                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2312                         break;
2313
2314                         case 1:
2315                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2316                         break;
2317
2318                         case 2:
2319                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2320                         break;
2321
2322                         case 3:
2323                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2324                         break;
2325
2326                         case 4:
2327                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2328                         break;
2329
2330                         case 5:
2331                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2332                         break;
2333
2334                         case 6:
2335                         break;
2336
2337                         case 7:
2338                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2339                         break;
2340
2341                         case 8:
2342                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2343                         break;
2344
2345                         case 9:
2346                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2347                         break;
2348
2349                         default:
2350                         break;
2351
2352                 }
2353         }
2354         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2355         return NDR_ERR_SUCCESS;
2356 }
2357
2358 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2359 {
2360         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2361         int level;
2362         level = ndr_pull_get_switch_value(ndr, r);
2363         if (ndr_flags & NDR_SCALARS) {
2364                 switch (level) {
2365                         case 0: {
2366                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2367                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2368                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2369                         break; }
2370
2371                         case 1: {
2372                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2373                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2374                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2375                         break; }
2376
2377                         case 2: {
2378                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2379                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2380                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2381                         break; }
2382
2383                         case 3: {
2384                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2385                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2386                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2387                         break; }
2388
2389                         case 4: {
2390                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2391                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2392                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2393                         break; }
2394
2395                         case 5: {
2396                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2397                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2399                         break; }
2400
2401                         case 6: {
2402                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2403                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2404                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2405                         break; }
2406
2407                         case 7: {
2408                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2409                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2411                         break; }
2412
2413                         case 8: {
2414                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2415                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2416                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2417                         break; }
2418
2419                         case 9: {
2420                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2421                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2422                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2423                         break; }
2424
2425                         default: {
2426                         break; }
2427
2428                 }
2429         }
2430         if (ndr_flags & NDR_BUFFERS) {
2431                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2432                 switch (level) {
2433                         case 0:
2434                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2435                         break;
2436
2437                         case 1:
2438                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2439                         break;
2440
2441                         case 2:
2442                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2443                         break;
2444
2445                         case 3:
2446                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2447                         break;
2448
2449                         case 4:
2450                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2451                         break;
2452
2453                         case 5:
2454                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2455                         break;
2456
2457                         case 6:
2458                         break;
2459
2460                         case 7:
2461                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2462                         break;
2463
2464                         case 8:
2465                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2466                         break;
2467
2468                         case 9:
2469                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2470                         break;
2471
2472                         default:
2473                         break;
2474
2475                 }
2476         }
2477         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2478         return NDR_ERR_SUCCESS;
2479 }
2480
2481 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2482 {
2483         int level;
2484         level = ndr_print_get_switch_value(ndr, r);
2485         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2486         switch (level) {
2487                 case 0:
2488                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2489                 break;
2490
2491                 case 1:
2492                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2493                 break;
2494
2495                 case 2:
2496                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2497                 break;
2498
2499                 case 3:
2500                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2501                 break;
2502
2503                 case 4:
2504                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2505                 break;
2506
2507                 case 5:
2508                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2509                 break;
2510
2511                 case 6:
2512                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2513                 break;
2514
2515                 case 7:
2516                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2517                 break;
2518
2519                 case 8:
2520                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2521                 break;
2522
2523                 case 9:
2524                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2525                 break;
2526
2527                 default:
2528                 break;
2529
2530         }
2531 }
2532
2533 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2534 {
2535         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2536 }
2537
2538 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2539 {
2540         if (ndr_flags & NDR_SCALARS) {
2541                 NDR_CHECK(ndr_push_align(ndr, 4));
2542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2544         }
2545         if (ndr_flags & NDR_BUFFERS) {
2546                 if (r->devmode) {
2547                         {
2548                                 struct ndr_push *_ndr_devmode;
2549                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2550                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2551                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2552                         }
2553                 }
2554         }
2555         return NDR_ERR_SUCCESS;
2556 }
2557
2558 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2559 {
2560         uint32_t _ptr_devmode;
2561         TALLOC_CTX *_mem_save_devmode_0;
2562         if (ndr_flags & NDR_SCALARS) {
2563                 NDR_CHECK(ndr_pull_align(ndr, 4));
2564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2566                 if (_ptr_devmode) {
2567                         NDR_PULL_ALLOC(ndr, r->devmode);
2568                 } else {
2569                         r->devmode = NULL;
2570                 }
2571         }
2572         if (ndr_flags & NDR_BUFFERS) {
2573                 if (r->devmode) {
2574                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2575                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2576                         {
2577                                 struct ndr_pull *_ndr_devmode;
2578                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2579                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2580                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2581                         }
2582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2583                 }
2584         }
2585         return NDR_ERR_SUCCESS;
2586 }
2587
2588 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2589 {
2590         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2591         ndr->depth++;
2592         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);
2593         ndr_print_ptr(ndr, "devmode", r->devmode);
2594         ndr->depth++;
2595         if (r->devmode) {
2596                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2597         }
2598         ndr->depth--;
2599         ndr->depth--;
2600 }
2601
2602 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2603 {
2604         if (ndr_flags & NDR_SCALARS) {
2605                 NDR_CHECK(ndr_push_align(ndr, 4));
2606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2607                 {
2608                         uint32_t _flags_save_string = ndr->flags;
2609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2611                         ndr->flags = _flags_save_string;
2612                 }
2613                 {
2614                         uint32_t _flags_save_string = ndr->flags;
2615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2616                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2617                         ndr->flags = _flags_save_string;
2618                 }
2619                 {
2620                         uint32_t _flags_save_string = ndr->flags;
2621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2622                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2623                         ndr->flags = _flags_save_string;
2624                 }
2625                 {
2626                         uint32_t _flags_save_string = ndr->flags;
2627                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2628                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2629                         ndr->flags = _flags_save_string;
2630                 }
2631                 {
2632                         uint32_t _flags_save_string = ndr->flags;
2633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2634                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2635                         ndr->flags = _flags_save_string;
2636                 }
2637                 {
2638                         uint32_t _flags_save_string = ndr->flags;
2639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2640                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2641                         ndr->flags = _flags_save_string;
2642                 }
2643                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2648                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2649         }
2650         if (ndr_flags & NDR_BUFFERS) {
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->printer_name) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660                 {
2661                         uint32_t _flags_save_string = ndr->flags;
2662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2663                         if (r->server_name) {
2664                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2665                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2666                         }
2667                         ndr->flags = _flags_save_string;
2668                 }
2669                 {
2670                         uint32_t _flags_save_string = ndr->flags;
2671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2672                         if (r->user_name) {
2673                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2674                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2675                         }
2676                         ndr->flags = _flags_save_string;
2677                 }
2678                 {
2679                         uint32_t _flags_save_string = ndr->flags;
2680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2681                         if (r->document_name) {
2682                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2683                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2684                         }
2685                         ndr->flags = _flags_save_string;
2686                 }
2687                 {
2688                         uint32_t _flags_save_string = ndr->flags;
2689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2690                         if (r->data_type) {
2691                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2692                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2693                         }
2694                         ndr->flags = _flags_save_string;
2695                 }
2696                 {
2697                         uint32_t _flags_save_string = ndr->flags;
2698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2699                         if (r->text_status) {
2700                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2701                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705         }
2706         return NDR_ERR_SUCCESS;
2707 }
2708
2709 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2710 {
2711         uint32_t _ptr_printer_name;
2712         TALLOC_CTX *_mem_save_printer_name_0;
2713         uint32_t _ptr_server_name;
2714         TALLOC_CTX *_mem_save_server_name_0;
2715         uint32_t _ptr_user_name;
2716         TALLOC_CTX *_mem_save_user_name_0;
2717         uint32_t _ptr_document_name;
2718         TALLOC_CTX *_mem_save_document_name_0;
2719         uint32_t _ptr_data_type;
2720         TALLOC_CTX *_mem_save_data_type_0;
2721         uint32_t _ptr_text_status;
2722         TALLOC_CTX *_mem_save_text_status_0;
2723         if (ndr_flags & NDR_SCALARS) {
2724                 NDR_CHECK(ndr_pull_align(ndr, 4));
2725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2726                 {
2727                         uint32_t _flags_save_string = ndr->flags;
2728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2730                         if (_ptr_printer_name) {
2731                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2733                         } else {
2734                                 r->printer_name = NULL;
2735                         }
2736                         ndr->flags = _flags_save_string;
2737                 }
2738                 {
2739                         uint32_t _flags_save_string = ndr->flags;
2740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2741                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2742                         if (_ptr_server_name) {
2743                                 NDR_PULL_ALLOC(ndr, r->server_name);
2744                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2745                         } else {
2746                                 r->server_name = NULL;
2747                         }
2748                         ndr->flags = _flags_save_string;
2749                 }
2750                 {
2751                         uint32_t _flags_save_string = ndr->flags;
2752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2754                         if (_ptr_user_name) {
2755                                 NDR_PULL_ALLOC(ndr, r->user_name);
2756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2757                         } else {
2758                                 r->user_name = NULL;
2759                         }
2760                         ndr->flags = _flags_save_string;
2761                 }
2762                 {
2763                         uint32_t _flags_save_string = ndr->flags;
2764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2765                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2766                         if (_ptr_document_name) {
2767                                 NDR_PULL_ALLOC(ndr, r->document_name);
2768                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2769                         } else {
2770                                 r->document_name = NULL;
2771                         }
2772                         ndr->flags = _flags_save_string;
2773                 }
2774                 {
2775                         uint32_t _flags_save_string = ndr->flags;
2776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2777                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2778                         if (_ptr_data_type) {
2779                                 NDR_PULL_ALLOC(ndr, r->data_type);
2780                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2781                         } else {
2782                                 r->data_type = NULL;
2783                         }
2784                         ndr->flags = _flags_save_string;
2785                 }
2786                 {
2787                         uint32_t _flags_save_string = ndr->flags;
2788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2789                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2790                         if (_ptr_text_status) {
2791                                 NDR_PULL_ALLOC(ndr, r->text_status);
2792                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2793                         } else {
2794                                 r->text_status = NULL;
2795                         }
2796                         ndr->flags = _flags_save_string;
2797                 }
2798                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2803                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2804         }
2805         if (ndr_flags & NDR_BUFFERS) {
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->printer_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2813                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_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->server_name) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2828                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_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->user_name) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2843                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851                 {
2852                         uint32_t _flags_save_string = ndr->flags;
2853                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2854                         if (r->document_name) {
2855                                 uint32_t _relative_save_offset;
2856                                 _relative_save_offset = ndr->offset;
2857                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2858                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2859                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2860                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2861                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2862                                 ndr->offset = _relative_save_offset;
2863                         }
2864                         ndr->flags = _flags_save_string;
2865                 }
2866                 {
2867                         uint32_t _flags_save_string = ndr->flags;
2868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2869                         if (r->data_type) {
2870                                 uint32_t _relative_save_offset;
2871                                 _relative_save_offset = ndr->offset;
2872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2873                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2874                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2877                                 ndr->offset = _relative_save_offset;
2878                         }
2879                         ndr->flags = _flags_save_string;
2880                 }
2881                 {
2882                         uint32_t _flags_save_string = ndr->flags;
2883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2884                         if (r->text_status) {
2885                                 uint32_t _relative_save_offset;
2886                                 _relative_save_offset = ndr->offset;
2887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2888                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2889                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2892                                 ndr->offset = _relative_save_offset;
2893                         }
2894                         ndr->flags = _flags_save_string;
2895                 }
2896         }
2897         return NDR_ERR_SUCCESS;
2898 }
2899
2900 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2901 {
2902         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2903         ndr->depth++;
2904         ndr_print_uint32(ndr, "job_id", r->job_id);
2905         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2906         ndr->depth++;
2907         if (r->printer_name) {
2908                 ndr_print_string(ndr, "printer_name", r->printer_name);
2909         }
2910         ndr->depth--;
2911         ndr_print_ptr(ndr, "server_name", r->server_name);
2912         ndr->depth++;
2913         if (r->server_name) {
2914                 ndr_print_string(ndr, "server_name", r->server_name);
2915         }
2916         ndr->depth--;
2917         ndr_print_ptr(ndr, "user_name", r->user_name);
2918         ndr->depth++;
2919         if (r->user_name) {
2920                 ndr_print_string(ndr, "user_name", r->user_name);
2921         }
2922         ndr->depth--;
2923         ndr_print_ptr(ndr, "document_name", r->document_name);
2924         ndr->depth++;
2925         if (r->document_name) {
2926                 ndr_print_string(ndr, "document_name", r->document_name);
2927         }
2928         ndr->depth--;
2929         ndr_print_ptr(ndr, "data_type", r->data_type);
2930         ndr->depth++;
2931         if (r->data_type) {
2932                 ndr_print_string(ndr, "data_type", r->data_type);
2933         }
2934         ndr->depth--;
2935         ndr_print_ptr(ndr, "text_status", r->text_status);
2936         ndr->depth++;
2937         if (r->text_status) {
2938                 ndr_print_string(ndr, "text_status", r->text_status);
2939         }
2940         ndr->depth--;
2941         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2942         ndr_print_uint32(ndr, "priority", r->priority);
2943         ndr_print_uint32(ndr, "position", r->position);
2944         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2945         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2946         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2947         ndr->depth--;
2948 }
2949
2950 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2951 {
2952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2953 }
2954
2955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2956 {
2957         if (ndr_flags & NDR_SCALARS) {
2958                 NDR_CHECK(ndr_push_align(ndr, 4));
2959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2960                 {
2961                         uint32_t _flags_save_string = ndr->flags;
2962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2964                         ndr->flags = _flags_save_string;
2965                 }
2966                 {
2967                         uint32_t _flags_save_string = ndr->flags;
2968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2970                         ndr->flags = _flags_save_string;
2971                 }
2972                 {
2973                         uint32_t _flags_save_string = ndr->flags;
2974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2976                         ndr->flags = _flags_save_string;
2977                 }
2978                 {
2979                         uint32_t _flags_save_string = ndr->flags;
2980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2982                         ndr->flags = _flags_save_string;
2983                 }
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2988                         ndr->flags = _flags_save_string;
2989                 }
2990                 {
2991                         uint32_t _flags_save_string = ndr->flags;
2992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2994                         ndr->flags = _flags_save_string;
2995                 }
2996                 {
2997                         uint32_t _flags_save_string = ndr->flags;
2998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3006                         ndr->flags = _flags_save_string;
3007                 }
3008                 {
3009                         uint32_t _flags_save_string = ndr->flags;
3010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3015                 {
3016                         uint32_t _flags_save_string = ndr->flags;
3017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3018                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3019                         ndr->flags = _flags_save_string;
3020                 }
3021                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3022                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3029                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3032         }
3033         if (ndr_flags & NDR_BUFFERS) {
3034                 {
3035                         uint32_t _flags_save_string = ndr->flags;
3036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3037                         if (r->printer_name) {
3038                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3039                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
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->server_name) {
3047                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3048                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
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->user_name) {
3056                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3057                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
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->document_name) {
3065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3067                         }
3068                         ndr->flags = _flags_save_string;
3069                 }
3070                 {
3071                         uint32_t _flags_save_string = ndr->flags;
3072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3073                         if (r->notify_name) {
3074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3076                         }
3077                         ndr->flags = _flags_save_string;
3078                 }
3079                 {
3080                         uint32_t _flags_save_string = ndr->flags;
3081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3082                         if (r->data_type) {
3083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3085                         }
3086                         ndr->flags = _flags_save_string;
3087                 }
3088                 {
3089                         uint32_t _flags_save_string = ndr->flags;
3090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3091                         if (r->print_processor) {
3092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3094                         }
3095                         ndr->flags = _flags_save_string;
3096                 }
3097                 {
3098                         uint32_t _flags_save_string = ndr->flags;
3099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3100                         if (r->parameters) {
3101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3103                         }
3104                         ndr->flags = _flags_save_string;
3105                 }
3106                 {
3107                         uint32_t _flags_save_string = ndr->flags;
3108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3109                         if (r->driver_name) {
3110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3112                         }
3113                         ndr->flags = _flags_save_string;
3114                 }
3115                 if (r->devmode) {
3116                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3117                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3118                 }
3119                 {
3120                         uint32_t _flags_save_string = ndr->flags;
3121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3122                         if (r->text_status) {
3123                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3124                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3125                         }
3126                         ndr->flags = _flags_save_string;
3127                 }
3128                 if (r->secdesc) {
3129                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3130                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3131                 }
3132         }
3133         return NDR_ERR_SUCCESS;
3134 }
3135
3136 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3137 {
3138         uint32_t _ptr_printer_name;
3139         TALLOC_CTX *_mem_save_printer_name_0;
3140         uint32_t _ptr_server_name;
3141         TALLOC_CTX *_mem_save_server_name_0;
3142         uint32_t _ptr_user_name;
3143         TALLOC_CTX *_mem_save_user_name_0;
3144         uint32_t _ptr_document_name;
3145         TALLOC_CTX *_mem_save_document_name_0;
3146         uint32_t _ptr_notify_name;
3147         TALLOC_CTX *_mem_save_notify_name_0;
3148         uint32_t _ptr_data_type;
3149         TALLOC_CTX *_mem_save_data_type_0;
3150         uint32_t _ptr_print_processor;
3151         TALLOC_CTX *_mem_save_print_processor_0;
3152         uint32_t _ptr_parameters;
3153         TALLOC_CTX *_mem_save_parameters_0;
3154         uint32_t _ptr_driver_name;
3155         TALLOC_CTX *_mem_save_driver_name_0;
3156         uint32_t _ptr_devmode;
3157         TALLOC_CTX *_mem_save_devmode_0;
3158         uint32_t _ptr_text_status;
3159         TALLOC_CTX *_mem_save_text_status_0;
3160         uint32_t _ptr_secdesc;
3161         TALLOC_CTX *_mem_save_secdesc_0;
3162         if (ndr_flags & NDR_SCALARS) {
3163                 NDR_CHECK(ndr_pull_align(ndr, 4));
3164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3165                 {
3166                         uint32_t _flags_save_string = ndr->flags;
3167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3168                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3169                         if (_ptr_printer_name) {
3170                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3171                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3172                         } else {
3173                                 r->printer_name = NULL;
3174                         }
3175                         ndr->flags = _flags_save_string;
3176                 }
3177                 {
3178                         uint32_t _flags_save_string = ndr->flags;
3179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3180                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3181                         if (_ptr_server_name) {
3182                                 NDR_PULL_ALLOC(ndr, r->server_name);
3183                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3184                         } else {
3185                                 r->server_name = NULL;
3186                         }
3187                         ndr->flags = _flags_save_string;
3188                 }
3189                 {
3190                         uint32_t _flags_save_string = ndr->flags;
3191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3192                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3193                         if (_ptr_user_name) {
3194                                 NDR_PULL_ALLOC(ndr, r->user_name);
3195                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3196                         } else {
3197                                 r->user_name = NULL;
3198                         }
3199                         ndr->flags = _flags_save_string;
3200                 }
3201                 {
3202                         uint32_t _flags_save_string = ndr->flags;
3203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3204                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3205                         if (_ptr_document_name) {
3206                                 NDR_PULL_ALLOC(ndr, r->document_name);
3207                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3208                         } else {
3209                                 r->document_name = NULL;
3210                         }
3211                         ndr->flags = _flags_save_string;
3212                 }
3213                 {
3214                         uint32_t _flags_save_string = ndr->flags;
3215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3216                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3217                         if (_ptr_notify_name) {
3218                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3219                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3220                         } else {
3221                                 r->notify_name = NULL;
3222                         }
3223                         ndr->flags = _flags_save_string;
3224                 }
3225                 {
3226                         uint32_t _flags_save_string = ndr->flags;
3227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3228                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3229                         if (_ptr_data_type) {
3230                                 NDR_PULL_ALLOC(ndr, r->data_type);
3231                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3232                         } else {
3233                                 r->data_type = NULL;
3234                         }
3235                         ndr->flags = _flags_save_string;
3236                 }
3237                 {
3238                         uint32_t _flags_save_string = ndr->flags;
3239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3240                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3241                         if (_ptr_print_processor) {
3242                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3243                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3244                         } else {
3245                                 r->print_processor = NULL;
3246                         }
3247                         ndr->flags = _flags_save_string;
3248                 }
3249                 {
3250                         uint32_t _flags_save_string = ndr->flags;
3251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3252                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3253                         if (_ptr_parameters) {
3254                                 NDR_PULL_ALLOC(ndr, r->parameters);
3255                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3256                         } else {
3257                                 r->parameters = NULL;
3258                         }
3259                         ndr->flags = _flags_save_string;
3260                 }
3261                 {
3262                         uint32_t _flags_save_string = ndr->flags;
3263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3264                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3265                         if (_ptr_driver_name) {
3266                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3267                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3268                         } else {
3269                                 r->driver_name = NULL;
3270                         }
3271                         ndr->flags = _flags_save_string;
3272                 }
3273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3274                 if (_ptr_devmode) {
3275                         NDR_PULL_ALLOC(ndr, r->devmode);
3276                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3277                 } else {
3278                         r->devmode = NULL;
3279                 }
3280                 {
3281                         uint32_t _flags_save_string = ndr->flags;
3282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3283                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3284                         if (_ptr_text_status) {
3285                                 NDR_PULL_ALLOC(ndr, r->text_status);
3286                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3287                         } else {
3288                                 r->text_status = NULL;
3289                         }
3290                         ndr->flags = _flags_save_string;
3291                 }
3292                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3293                 if (_ptr_secdesc) {
3294                         NDR_PULL_ALLOC(ndr, r->secdesc);
3295                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3296                 } else {
3297                         r->secdesc = NULL;
3298                 }
3299                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3302                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3304                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3306                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3309         }
3310         if (ndr_flags & NDR_BUFFERS) {
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->printer_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3318                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_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->server_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3333                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_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->user_name) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3348                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_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->document_name) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3363                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_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->notify_name) {
3375                                 uint32_t _relative_save_offset;
3376                                 _relative_save_offset = ndr->offset;
3377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3378                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3379                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_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->data_type) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3393                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3397                                 ndr->offset = _relative_save_offset;
3398                         }
3399                         ndr->flags = _flags_save_string;
3400                 }
3401                 {
3402                         uint32_t _flags_save_string = ndr->flags;
3403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3404                         if (r->print_processor) {
3405                                 uint32_t _relative_save_offset;
3406                                 _relative_save_offset = ndr->offset;
3407                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3408                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3409                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3410                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3411                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3412                                 ndr->offset = _relative_save_offset;
3413                         }
3414                         ndr->flags = _flags_save_string;
3415                 }
3416                 {
3417                         uint32_t _flags_save_string = ndr->flags;
3418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3419                         if (r->parameters) {
3420                                 uint32_t _relative_save_offset;
3421                                 _relative_save_offset = ndr->offset;
3422                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3423                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3424                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3425                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3426                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3427                                 ndr->offset = _relative_save_offset;
3428                         }
3429                         ndr->flags = _flags_save_string;
3430                 }
3431                 {
3432                         uint32_t _flags_save_string = ndr->flags;
3433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3434                         if (r->driver_name) {
3435                                 uint32_t _relative_save_offset;
3436                                 _relative_save_offset = ndr->offset;
3437                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3438                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3439                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3440                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3441                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3442                                 ndr->offset = _relative_save_offset;
3443                         }
3444                         ndr->flags = _flags_save_string;
3445                 }
3446                 if (r->devmode) {
3447                         uint32_t _relative_save_offset;
3448                         _relative_save_offset = ndr->offset;
3449                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3450                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3451                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3452                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3454                         ndr->offset = _relative_save_offset;
3455                 }
3456                 {
3457                         uint32_t _flags_save_string = ndr->flags;
3458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3459                         if (r->text_status) {
3460                                 uint32_t _relative_save_offset;
3461                                 _relative_save_offset = ndr->offset;
3462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3463                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3464                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3467                                 ndr->offset = _relative_save_offset;
3468                         }
3469                         ndr->flags = _flags_save_string;
3470                 }
3471                 if (r->secdesc) {
3472                         uint32_t _relative_save_offset;
3473                         _relative_save_offset = ndr->offset;
3474                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3475                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3476                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3477                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3479                         ndr->offset = _relative_save_offset;
3480                 }
3481         }
3482         return NDR_ERR_SUCCESS;
3483 }
3484
3485 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3486 {
3487         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3488         ndr->depth++;
3489         ndr_print_uint32(ndr, "job_id", r->job_id);
3490         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3491         ndr->depth++;
3492         if (r->printer_name) {
3493                 ndr_print_string(ndr, "printer_name", r->printer_name);
3494         }
3495         ndr->depth--;
3496         ndr_print_ptr(ndr, "server_name", r->server_name);
3497         ndr->depth++;
3498         if (r->server_name) {
3499                 ndr_print_string(ndr, "server_name", r->server_name);
3500         }
3501         ndr->depth--;
3502         ndr_print_ptr(ndr, "user_name", r->user_name);
3503         ndr->depth++;
3504         if (r->user_name) {
3505                 ndr_print_string(ndr, "user_name", r->user_name);
3506         }
3507         ndr->depth--;
3508         ndr_print_ptr(ndr, "document_name", r->document_name);
3509         ndr->depth++;
3510         if (r->document_name) {
3511                 ndr_print_string(ndr, "document_name", r->document_name);
3512         }
3513         ndr->depth--;
3514         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3515         ndr->depth++;
3516         if (r->notify_name) {
3517                 ndr_print_string(ndr, "notify_name", r->notify_name);
3518         }
3519         ndr->depth--;
3520         ndr_print_ptr(ndr, "data_type", r->data_type);
3521         ndr->depth++;
3522         if (r->data_type) {
3523                 ndr_print_string(ndr, "data_type", r->data_type);
3524         }
3525         ndr->depth--;
3526         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3527         ndr->depth++;
3528         if (r->print_processor) {
3529                 ndr_print_string(ndr, "print_processor", r->print_processor);
3530         }
3531         ndr->depth--;
3532         ndr_print_ptr(ndr, "parameters", r->parameters);
3533         ndr->depth++;
3534         if (r->parameters) {
3535                 ndr_print_string(ndr, "parameters", r->parameters);
3536         }
3537         ndr->depth--;
3538         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3539         ndr->depth++;
3540         if (r->driver_name) {
3541                 ndr_print_string(ndr, "driver_name", r->driver_name);
3542         }
3543         ndr->depth--;
3544         ndr_print_ptr(ndr, "devmode", r->devmode);
3545         ndr->depth++;
3546         if (r->devmode) {
3547                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3548         }
3549         ndr->depth--;
3550         ndr_print_ptr(ndr, "text_status", r->text_status);
3551         ndr->depth++;
3552         if (r->text_status) {
3553                 ndr_print_string(ndr, "text_status", r->text_status);
3554         }
3555         ndr->depth--;
3556         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3557         ndr->depth++;
3558         if (r->secdesc) {
3559                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3560         }
3561         ndr->depth--;
3562         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3563         ndr_print_uint32(ndr, "priority", r->priority);
3564         ndr_print_uint32(ndr, "position", r->position);
3565         ndr_print_uint32(ndr, "start_time", r->start_time);
3566         ndr_print_uint32(ndr, "until_time", r->until_time);
3567         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3568         ndr_print_uint32(ndr, "size", r->size);
3569         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3570         ndr_print_uint32(ndr, "time", r->time);
3571         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3572         ndr->depth--;
3573 }
3574
3575 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3576 {
3577         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3578 }
3579
3580 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3581 {
3582         if (ndr_flags & NDR_SCALARS) {
3583                 NDR_CHECK(ndr_push_align(ndr, 4));
3584                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3587         }
3588         if (ndr_flags & NDR_BUFFERS) {
3589         }
3590         return NDR_ERR_SUCCESS;
3591 }
3592
3593 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3594 {
3595         if (ndr_flags & NDR_SCALARS) {
3596                 NDR_CHECK(ndr_pull_align(ndr, 4));
3597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3600         }
3601         if (ndr_flags & NDR_BUFFERS) {
3602         }
3603         return NDR_ERR_SUCCESS;
3604 }
3605
3606 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3607 {
3608         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3609         ndr->depth++;
3610         ndr_print_uint32(ndr, "job_id", r->job_id);
3611         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3612         ndr_print_uint32(ndr, "reserved", r->reserved);
3613         ndr->depth--;
3614 }
3615
3616 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3617 {
3618         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3619 }
3620
3621 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3622 {
3623         if (ndr_flags & NDR_SCALARS) {
3624                 NDR_CHECK(ndr_push_align(ndr, 4));
3625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3626                 {
3627                         uint32_t _flags_save_string = ndr->flags;
3628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3630                         ndr->flags = _flags_save_string;
3631                 }
3632                 {
3633                         uint32_t _flags_save_string = ndr->flags;
3634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3635                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3636                         ndr->flags = _flags_save_string;
3637                 }
3638                 {
3639                         uint32_t _flags_save_string = ndr->flags;
3640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3641                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3642                         ndr->flags = _flags_save_string;
3643                 }
3644                 {
3645                         uint32_t _flags_save_string = ndr->flags;
3646                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3647                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3648                         ndr->flags = _flags_save_string;
3649                 }
3650                 {
3651                         uint32_t _flags_save_string = ndr->flags;
3652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3653                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3654                         ndr->flags = _flags_save_string;
3655                 }
3656                 {
3657                         uint32_t _flags_save_string = ndr->flags;
3658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3659                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3660                         ndr->flags = _flags_save_string;
3661                 }
3662                 {
3663                         uint32_t _flags_save_string = ndr->flags;
3664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3665                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3666                         ndr->flags = _flags_save_string;
3667                 }
3668                 {
3669                         uint32_t _flags_save_string = ndr->flags;
3670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3671                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3678                         ndr->flags = _flags_save_string;
3679                 }
3680                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3681                 {
3682                         uint32_t _flags_save_string = ndr->flags;
3683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3684                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3685                         ndr->flags = _flags_save_string;
3686                 }
3687                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3688                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3695                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3699         }
3700         if (ndr_flags & NDR_BUFFERS) {
3701                 {
3702                         uint32_t _flags_save_string = ndr->flags;
3703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3704                         if (r->printer_name) {
3705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
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->server_name) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
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->user_name) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
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->document_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 {
3738                         uint32_t _flags_save_string = ndr->flags;
3739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3740                         if (r->notify_name) {
3741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3743                         }
3744                         ndr->flags = _flags_save_string;
3745                 }
3746                 {
3747                         uint32_t _flags_save_string = ndr->flags;
3748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3749                         if (r->data_type) {
3750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3752                         }
3753                         ndr->flags = _flags_save_string;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         if (r->print_processor) {
3759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3761                         }
3762                         ndr->flags = _flags_save_string;
3763                 }
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         if (r->parameters) {
3768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3770                         }
3771                         ndr->flags = _flags_save_string;
3772                 }
3773                 {
3774                         uint32_t _flags_save_string = ndr->flags;
3775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3776                         if (r->driver_name) {
3777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3779                         }
3780                         ndr->flags = _flags_save_string;
3781                 }
3782                 if (r->devmode) {
3783                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3784                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3785                 }
3786                 {
3787                         uint32_t _flags_save_string = ndr->flags;
3788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3789                         if (r->text_status) {
3790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3792                         }
3793                         ndr->flags = _flags_save_string;
3794                 }
3795                 if (r->secdesc) {
3796                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3797                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3798                 }
3799         }
3800         return NDR_ERR_SUCCESS;
3801 }
3802
3803 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3804 {
3805         uint32_t _ptr_printer_name;
3806         TALLOC_CTX *_mem_save_printer_name_0;
3807         uint32_t _ptr_server_name;
3808         TALLOC_CTX *_mem_save_server_name_0;
3809         uint32_t _ptr_user_name;
3810         TALLOC_CTX *_mem_save_user_name_0;
3811         uint32_t _ptr_document_name;
3812         TALLOC_CTX *_mem_save_document_name_0;
3813         uint32_t _ptr_notify_name;
3814         TALLOC_CTX *_mem_save_notify_name_0;
3815         uint32_t _ptr_data_type;
3816         TALLOC_CTX *_mem_save_data_type_0;
3817         uint32_t _ptr_print_processor;
3818         TALLOC_CTX *_mem_save_print_processor_0;
3819         uint32_t _ptr_parameters;
3820         TALLOC_CTX *_mem_save_parameters_0;
3821         uint32_t _ptr_driver_name;
3822         TALLOC_CTX *_mem_save_driver_name_0;
3823         uint32_t _ptr_devmode;
3824         TALLOC_CTX *_mem_save_devmode_0;
3825         uint32_t _ptr_text_status;
3826         TALLOC_CTX *_mem_save_text_status_0;
3827         uint32_t _ptr_secdesc;
3828         TALLOC_CTX *_mem_save_secdesc_0;
3829         if (ndr_flags & NDR_SCALARS) {
3830                 NDR_CHECK(ndr_pull_align(ndr, 4));
3831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3832                 {
3833                         uint32_t _flags_save_string = ndr->flags;
3834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3835                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3836                         if (_ptr_printer_name) {
3837                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3839                         } else {
3840                                 r->printer_name = NULL;
3841                         }
3842                         ndr->flags = _flags_save_string;
3843                 }
3844                 {
3845                         uint32_t _flags_save_string = ndr->flags;
3846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3847                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3848                         if (_ptr_server_name) {
3849                                 NDR_PULL_ALLOC(ndr, r->server_name);
3850                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3851                         } else {
3852                                 r->server_name = NULL;
3853                         }
3854                         ndr->flags = _flags_save_string;
3855                 }
3856                 {
3857                         uint32_t _flags_save_string = ndr->flags;
3858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3860                         if (_ptr_user_name) {
3861                                 NDR_PULL_ALLOC(ndr, r->user_name);
3862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3863                         } else {
3864                                 r->user_name = NULL;
3865                         }
3866                         ndr->flags = _flags_save_string;
3867                 }
3868                 {
3869                         uint32_t _flags_save_string = ndr->flags;
3870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3871                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3872                         if (_ptr_document_name) {
3873                                 NDR_PULL_ALLOC(ndr, r->document_name);
3874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3875                         } else {
3876                                 r->document_name = NULL;
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 {
3881                         uint32_t _flags_save_string = ndr->flags;
3882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3883                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3884                         if (_ptr_notify_name) {
3885                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3886                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3887                         } else {
3888                                 r->notify_name = NULL;
3889                         }
3890                         ndr->flags = _flags_save_string;
3891                 }
3892                 {
3893                         uint32_t _flags_save_string = ndr->flags;
3894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3896                         if (_ptr_data_type) {
3897                                 NDR_PULL_ALLOC(ndr, r->data_type);
3898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3899                         } else {
3900                                 r->data_type = NULL;
3901                         }
3902                         ndr->flags = _flags_save_string;
3903                 }
3904                 {
3905                         uint32_t _flags_save_string = ndr->flags;
3906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3908                         if (_ptr_print_processor) {
3909                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3911                         } else {
3912                                 r->print_processor = NULL;
3913                         }
3914                         ndr->flags = _flags_save_string;
3915                 }
3916                 {
3917                         uint32_t _flags_save_string = ndr->flags;
3918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3920                         if (_ptr_parameters) {
3921                                 NDR_PULL_ALLOC(ndr, r->parameters);
3922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3923                         } else {
3924                                 r->parameters = NULL;
3925                         }
3926                         ndr->flags = _flags_save_string;
3927                 }
3928                 {
3929                         uint32_t _flags_save_string = ndr->flags;
3930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3932                         if (_ptr_driver_name) {
3933                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3935                         } else {
3936                                 r->driver_name = NULL;
3937                         }
3938                         ndr->flags = _flags_save_string;
3939                 }
3940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3941                 if (_ptr_devmode) {
3942                         NDR_PULL_ALLOC(ndr, r->devmode);
3943                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3944                 } else {
3945                         r->devmode = NULL;
3946                 }
3947                 {
3948                         uint32_t _flags_save_string = ndr->flags;
3949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3951                         if (_ptr_text_status) {
3952                                 NDR_PULL_ALLOC(ndr, r->text_status);
3953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3954                         } else {
3955                                 r->text_status = NULL;
3956                         }
3957                         ndr->flags = _flags_save_string;
3958                 }
3959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3960                 if (_ptr_secdesc) {
3961                         NDR_PULL_ALLOC(ndr, r->secdesc);
3962                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3963                 } else {
3964                         r->secdesc = NULL;
3965                 }
3966                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3973                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3977         }
3978         if (ndr_flags & NDR_BUFFERS) {
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->printer_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3986                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_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->server_name) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4001                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_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->user_name) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4016                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_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->document_name) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4031                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_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->notify_name) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4046                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_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->data_type) {
4058                                 uint32_t _relative_save_offset;
4059                                 _relative_save_offset = ndr->offset;
4060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4061                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4062                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4065                                 ndr->offset = _relative_save_offset;
4066                         }
4067                         ndr->flags = _flags_save_string;
4068                 }
4069                 {
4070                         uint32_t _flags_save_string = ndr->flags;
4071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4072                         if (r->print_processor) {
4073                                 uint32_t _relative_save_offset;
4074                                 _relative_save_offset = ndr->offset;
4075                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4076                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4077                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4078                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4079                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4080                                 ndr->offset = _relative_save_offset;
4081                         }
4082                         ndr->flags = _flags_save_string;
4083                 }
4084                 {
4085                         uint32_t _flags_save_string = ndr->flags;
4086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4087                         if (r->parameters) {
4088                                 uint32_t _relative_save_offset;
4089                                 _relative_save_offset = ndr->offset;
4090                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4091                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4092                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4093                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4094                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4095                                 ndr->offset = _relative_save_offset;
4096                         }
4097                         ndr->flags = _flags_save_string;
4098                 }
4099                 {
4100                         uint32_t _flags_save_string = ndr->flags;
4101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4102                         if (r->driver_name) {
4103                                 uint32_t _relative_save_offset;
4104                                 _relative_save_offset = ndr->offset;
4105                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4106                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4107                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4108                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4109                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4110                                 ndr->offset = _relative_save_offset;
4111                         }
4112                         ndr->flags = _flags_save_string;
4113                 }
4114                 if (r->devmode) {
4115                         uint32_t _relative_save_offset;
4116                         _relative_save_offset = ndr->offset;
4117                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4118                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4120                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4122                         ndr->offset = _relative_save_offset;
4123                 }
4124                 {
4125                         uint32_t _flags_save_string = ndr->flags;
4126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4127                         if (r->text_status) {
4128                                 uint32_t _relative_save_offset;
4129                                 _relative_save_offset = ndr->offset;
4130                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4131                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4132                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4133                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4134                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4135                                 ndr->offset = _relative_save_offset;
4136                         }
4137                         ndr->flags = _flags_save_string;
4138                 }
4139                 if (r->secdesc) {
4140                         uint32_t _relative_save_offset;
4141                         _relative_save_offset = ndr->offset;
4142                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4143                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4145                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4147                         ndr->offset = _relative_save_offset;
4148                 }
4149         }
4150         return NDR_ERR_SUCCESS;
4151 }
4152
4153 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4154 {
4155         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4156         ndr->depth++;
4157         ndr_print_uint32(ndr, "job_id", r->job_id);
4158         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4159         ndr->depth++;
4160         if (r->printer_name) {
4161                 ndr_print_string(ndr, "printer_name", r->printer_name);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "server_name", r->server_name);
4165         ndr->depth++;
4166         if (r->server_name) {
4167                 ndr_print_string(ndr, "server_name", r->server_name);
4168         }
4169         ndr->depth--;
4170         ndr_print_ptr(ndr, "user_name", r->user_name);
4171         ndr->depth++;
4172         if (r->user_name) {
4173                 ndr_print_string(ndr, "user_name", r->user_name);
4174         }
4175         ndr->depth--;
4176         ndr_print_ptr(ndr, "document_name", r->document_name);
4177         ndr->depth++;
4178         if (r->document_name) {
4179                 ndr_print_string(ndr, "document_name", r->document_name);
4180         }
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4183         ndr->depth++;
4184         if (r->notify_name) {
4185                 ndr_print_string(ndr, "notify_name", r->notify_name);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "data_type", r->data_type);
4189         ndr->depth++;
4190         if (r->data_type) {
4191                 ndr_print_string(ndr, "data_type", r->data_type);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4195         ndr->depth++;
4196         if (r->print_processor) {
4197                 ndr_print_string(ndr, "print_processor", r->print_processor);
4198         }
4199         ndr->depth--;
4200         ndr_print_ptr(ndr, "parameters", r->parameters);
4201         ndr->depth++;
4202         if (r->parameters) {
4203                 ndr_print_string(ndr, "parameters", r->parameters);
4204         }
4205         ndr->depth--;
4206         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4207         ndr->depth++;
4208         if (r->driver_name) {
4209                 ndr_print_string(ndr, "driver_name", r->driver_name);
4210         }
4211         ndr->depth--;
4212         ndr_print_ptr(ndr, "devmode", r->devmode);
4213         ndr->depth++;
4214         if (r->devmode) {
4215                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4216         }
4217         ndr->depth--;
4218         ndr_print_ptr(ndr, "text_status", r->text_status);
4219         ndr->depth++;
4220         if (r->text_status) {
4221                 ndr_print_string(ndr, "text_status", r->text_status);
4222         }
4223         ndr->depth--;
4224         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4225         ndr->depth++;
4226         if (r->secdesc) {
4227                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4228         }
4229         ndr->depth--;
4230         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4231         ndr_print_uint32(ndr, "priority", r->priority);
4232         ndr_print_uint32(ndr, "position", r->position);
4233         ndr_print_uint32(ndr, "start_time", r->start_time);
4234         ndr_print_uint32(ndr, "until_time", r->until_time);
4235         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4236         ndr_print_uint32(ndr, "size", r->size);
4237         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4238         ndr_print_uint32(ndr, "time", r->time);
4239         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4240         ndr_print_uint32(ndr, "size_high", r->size_high);
4241         ndr->depth--;
4242 }
4243
4244 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4245 {
4246         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4247 }
4248
4249 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4250 {
4251         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4252         if (ndr_flags & NDR_SCALARS) {
4253                 int level = ndr_push_get_switch_value(ndr, r);
4254                 switch (level) {
4255                         case 1: {
4256                                 NDR_CHECK(ndr_push_align(ndr, 4));
4257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4258                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4259                         break; }
4260
4261                         case 2: {
4262                                 NDR_CHECK(ndr_push_align(ndr, 4));
4263                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4264                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4265                         break; }
4266
4267                         case 3: {
4268                                 NDR_CHECK(ndr_push_align(ndr, 4));
4269                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4270                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4271                         break; }
4272
4273                         case 4: {
4274                                 NDR_CHECK(ndr_push_align(ndr, 4));
4275                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4276                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4277                         break; }
4278
4279                         default: {
4280                         break; }
4281
4282                 }
4283         }
4284         if (ndr_flags & NDR_BUFFERS) {
4285                 int level = ndr_push_get_switch_value(ndr, r);
4286                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4287                 switch (level) {
4288                         case 1:
4289                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4290                         break;
4291
4292                         case 2:
4293                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4294                         break;
4295
4296                         case 3:
4297                         break;
4298
4299                         case 4:
4300                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4301                         break;
4302
4303                         default:
4304                         break;
4305
4306                 }
4307         }
4308         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4309         return NDR_ERR_SUCCESS;
4310 }
4311
4312 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4313 {
4314         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4315         int level;
4316         level = ndr_pull_get_switch_value(ndr, r);
4317         if (ndr_flags & NDR_SCALARS) {
4318                 switch (level) {
4319                         case 1: {
4320                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4321                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4322                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4323                         break; }
4324
4325                         case 2: {
4326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4328                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4329                         break; }
4330
4331                         case 3: {
4332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4334                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4335                         break; }
4336
4337                         case 4: {
4338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4340                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4341                         break; }
4342
4343                         default: {
4344                         break; }
4345
4346                 }
4347         }
4348         if (ndr_flags & NDR_BUFFERS) {
4349                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4350                 switch (level) {
4351                         case 1:
4352                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4353                         break;
4354
4355                         case 2:
4356                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4357                         break;
4358
4359                         case 3:
4360                         break;
4361
4362                         case 4:
4363                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4364                         break;
4365
4366                         default:
4367                         break;
4368
4369                 }
4370         }
4371         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4372         return NDR_ERR_SUCCESS;
4373 }
4374
4375 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4376 {
4377         int level;
4378         level = ndr_print_get_switch_value(ndr, r);
4379         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4380         switch (level) {
4381                 case 1:
4382                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4383                 break;
4384
4385                 case 2:
4386                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4387                 break;
4388
4389                 case 3:
4390                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4391                 break;
4392
4393                 case 4:
4394                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4395                 break;
4396
4397                 default:
4398                 break;
4399
4400         }
4401 }
4402
4403 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4404 {
4405         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4406 }
4407
4408 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4409 {
4410         if (ndr_flags & NDR_SCALARS) {
4411                 NDR_CHECK(ndr_push_align(ndr, 4));
4412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4419                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4424                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4425         }
4426         if (ndr_flags & NDR_BUFFERS) {
4427                 if (r->printer_name) {
4428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4431                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4432                 }
4433                 if (r->server_name) {
4434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4438                 }
4439                 if (r->user_name) {
4440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444                 }
4445                 if (r->document_name) {
4446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4450                 }
4451                 if (r->data_type) {
4452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4456                 }
4457                 if (r->text_status) {
4458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4462                 }
4463         }
4464         return NDR_ERR_SUCCESS;
4465 }
4466
4467 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4468 {
4469         uint32_t _ptr_printer_name;
4470         TALLOC_CTX *_mem_save_printer_name_0;
4471         uint32_t _ptr_server_name;
4472         TALLOC_CTX *_mem_save_server_name_0;
4473         uint32_t _ptr_user_name;
4474         TALLOC_CTX *_mem_save_user_name_0;
4475         uint32_t _ptr_document_name;
4476         TALLOC_CTX *_mem_save_document_name_0;
4477         uint32_t _ptr_data_type;
4478         TALLOC_CTX *_mem_save_data_type_0;
4479         uint32_t _ptr_text_status;
4480         TALLOC_CTX *_mem_save_text_status_0;
4481         if (ndr_flags & NDR_SCALARS) {
4482                 NDR_CHECK(ndr_pull_align(ndr, 4));
4483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4485                 if (_ptr_printer_name) {
4486                         NDR_PULL_ALLOC(ndr, r->printer_name);
4487                 } else {
4488                         r->printer_name = NULL;
4489                 }
4490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4491                 if (_ptr_server_name) {
4492                         NDR_PULL_ALLOC(ndr, r->server_name);
4493                 } else {
4494                         r->server_name = NULL;
4495                 }
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4497                 if (_ptr_user_name) {
4498                         NDR_PULL_ALLOC(ndr, r->user_name);
4499                 } else {
4500                         r->user_name = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4503                 if (_ptr_document_name) {
4504                         NDR_PULL_ALLOC(ndr, r->document_name);
4505                 } else {
4506                         r->document_name = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4509                 if (_ptr_data_type) {
4510                         NDR_PULL_ALLOC(ndr, r->data_type);
4511                 } else {
4512                         r->data_type = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4515                 if (_ptr_text_status) {
4516                         NDR_PULL_ALLOC(ndr, r->text_status);
4517                 } else {
4518                         r->text_status = NULL;
4519                 }
4520                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4525                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4526         }
4527         if (ndr_flags & NDR_BUFFERS) {
4528                 if (r->printer_name) {
4529                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4530                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4533                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4534                                 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));
4535                         }
4536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4539                 }
4540                 if (r->server_name) {
4541                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4542                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4545                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4546                                 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));
4547                         }
4548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4551                 }
4552                 if (r->user_name) {
4553                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4554                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4556                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4557                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4558                                 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));
4559                         }
4560                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4561                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4563                 }
4564                 if (r->document_name) {
4565                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4566                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4567                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4568                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4569                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4570                                 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));
4571                         }
4572                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4573                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4574                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4575                 }
4576                 if (r->data_type) {
4577                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4578                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4579                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4580                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4581                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4582                                 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));
4583                         }
4584                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4585                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4586                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4587                 }
4588                 if (r->text_status) {
4589                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4590                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4593                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4594                                 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));
4595                         }
4596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4599                 }
4600         }
4601         return NDR_ERR_SUCCESS;
4602 }
4603
4604 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4605 {
4606         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4607         ndr->depth++;
4608         ndr_print_uint32(ndr, "job_id", r->job_id);
4609         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4610         ndr->depth++;
4611         if (r->printer_name) {
4612                 ndr_print_string(ndr, "printer_name", r->printer_name);
4613         }
4614         ndr->depth--;
4615         ndr_print_ptr(ndr, "server_name", r->server_name);
4616         ndr->depth++;
4617         if (r->server_name) {
4618                 ndr_print_string(ndr, "server_name", r->server_name);
4619         }
4620         ndr->depth--;
4621         ndr_print_ptr(ndr, "user_name", r->user_name);
4622         ndr->depth++;
4623         if (r->user_name) {
4624                 ndr_print_string(ndr, "user_name", r->user_name);
4625         }
4626         ndr->depth--;
4627         ndr_print_ptr(ndr, "document_name", r->document_name);
4628         ndr->depth++;
4629         if (r->document_name) {
4630                 ndr_print_string(ndr, "document_name", r->document_name);
4631         }
4632         ndr->depth--;
4633         ndr_print_ptr(ndr, "data_type", r->data_type);
4634         ndr->depth++;
4635         if (r->data_type) {
4636                 ndr_print_string(ndr, "data_type", r->data_type);
4637         }
4638         ndr->depth--;
4639         ndr_print_ptr(ndr, "text_status", r->text_status);
4640         ndr->depth++;
4641         if (r->text_status) {
4642                 ndr_print_string(ndr, "text_status", r->text_status);
4643         }
4644         ndr->depth--;
4645         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4646         ndr_print_uint32(ndr, "priority", r->priority);
4647         ndr_print_uint32(ndr, "position", r->position);
4648         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4649         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4650         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4651         ndr->depth--;
4652 }
4653
4654 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4655 {
4656         if (ndr_flags & NDR_SCALARS) {
4657                 NDR_CHECK(ndr_push_align(ndr, 4));
4658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4660                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4666                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4668                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4671                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4678                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4681         }
4682         if (ndr_flags & NDR_BUFFERS) {
4683                 if (r->printer_name) {
4684                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4687                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4688                 }
4689                 if (r->server_name) {
4690                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4693                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4694                 }
4695                 if (r->user_name) {
4696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4700                 }
4701                 if (r->document_name) {
4702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4706                 }
4707                 if (r->notify_name) {
4708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4711                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4712                 }
4713                 if (r->data_type) {
4714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4718                 }
4719                 if (r->print_processor) {
4720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4723                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4724                 }
4725                 if (r->parameters) {
4726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4730                 }
4731                 if (r->driver_name) {
4732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4736                 }
4737                 if (r->text_status) {
4738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4742                 }
4743         }
4744         return NDR_ERR_SUCCESS;
4745 }
4746
4747 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4748 {
4749         uint32_t _ptr_printer_name;
4750         TALLOC_CTX *_mem_save_printer_name_0;
4751         uint32_t _ptr_server_name;
4752         TALLOC_CTX *_mem_save_server_name_0;
4753         uint32_t _ptr_user_name;
4754         TALLOC_CTX *_mem_save_user_name_0;
4755         uint32_t _ptr_document_name;
4756         TALLOC_CTX *_mem_save_document_name_0;
4757         uint32_t _ptr_notify_name;
4758         TALLOC_CTX *_mem_save_notify_name_0;
4759         uint32_t _ptr_data_type;
4760         TALLOC_CTX *_mem_save_data_type_0;
4761         uint32_t _ptr_print_processor;
4762         TALLOC_CTX *_mem_save_print_processor_0;
4763         uint32_t _ptr_parameters;
4764         TALLOC_CTX *_mem_save_parameters_0;
4765         uint32_t _ptr_driver_name;
4766         TALLOC_CTX *_mem_save_driver_name_0;
4767         uint32_t _ptr_text_status;
4768         TALLOC_CTX *_mem_save_text_status_0;
4769         if (ndr_flags & NDR_SCALARS) {
4770                 NDR_CHECK(ndr_pull_align(ndr, 4));
4771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4773                 if (_ptr_printer_name) {
4774                         NDR_PULL_ALLOC(ndr, r->printer_name);
4775                 } else {
4776                         r->printer_name = NULL;
4777                 }
4778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4779                 if (_ptr_server_name) {
4780                         NDR_PULL_ALLOC(ndr, r->server_name);
4781                 } else {
4782                         r->server_name = NULL;
4783                 }
4784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4785                 if (_ptr_user_name) {
4786                         NDR_PULL_ALLOC(ndr, r->user_name);
4787                 } else {
4788                         r->user_name = NULL;
4789                 }
4790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4791                 if (_ptr_document_name) {
4792                         NDR_PULL_ALLOC(ndr, r->document_name);
4793                 } else {
4794                         r->document_name = NULL;
4795                 }
4796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4797                 if (_ptr_notify_name) {
4798                         NDR_PULL_ALLOC(ndr, r->notify_name);
4799                 } else {
4800                         r->notify_name = NULL;
4801                 }
4802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4803                 if (_ptr_data_type) {
4804                         NDR_PULL_ALLOC(ndr, r->data_type);
4805                 } else {
4806                         r->data_type = NULL;
4807                 }
4808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4809                 if (_ptr_print_processor) {
4810                         NDR_PULL_ALLOC(ndr, r->print_processor);
4811                 } else {
4812                         r->print_processor = NULL;
4813                 }
4814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4815                 if (_ptr_parameters) {
4816                         NDR_PULL_ALLOC(ndr, r->parameters);
4817                 } else {
4818                         r->parameters = NULL;
4819                 }
4820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4821                 if (_ptr_driver_name) {
4822                         NDR_PULL_ALLOC(ndr, r->driver_name);
4823                 } else {
4824                         r->driver_name = NULL;
4825                 }
4826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4828                 if (_ptr_text_status) {
4829                         NDR_PULL_ALLOC(ndr, r->text_status);
4830                 } else {
4831                         r->text_status = NULL;
4832                 }
4833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4834                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4841                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4844         }
4845         if (ndr_flags & NDR_BUFFERS) {
4846                 if (r->printer_name) {
4847                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4848                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4851                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4852                                 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));
4853                         }
4854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4857                 }
4858                 if (r->server_name) {
4859                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4860                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4863                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4864                                 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));
4865                         }
4866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4869                 }
4870                 if (r->user_name) {
4871                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4872                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4875                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4876                                 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));
4877                         }
4878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4881                 }
4882                 if (r->document_name) {
4883                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4884                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4887                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4888                                 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));
4889                         }
4890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4893                 }
4894                 if (r->notify_name) {
4895                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4896                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4899                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4900                                 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));
4901                         }
4902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4905                 }
4906                 if (r->data_type) {
4907                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4908                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4911                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4912                                 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));
4913                         }
4914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4917                 }
4918                 if (r->print_processor) {
4919                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4920                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4923                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4924                                 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));
4925                         }
4926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4929                 }
4930                 if (r->parameters) {
4931                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4932                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4935                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4936                                 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));
4937                         }
4938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4941                 }
4942                 if (r->driver_name) {
4943                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4944                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4947                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4948                                 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));
4949                         }
4950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4953                 }
4954                 if (r->text_status) {
4955                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4956                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4959                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4960                                 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));
4961                         }
4962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4965                 }
4966         }
4967         return NDR_ERR_SUCCESS;
4968 }
4969
4970 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4971 {
4972         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4973         ndr->depth++;
4974         ndr_print_uint32(ndr, "job_id", r->job_id);
4975         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4976         ndr->depth++;
4977         if (r->printer_name) {
4978                 ndr_print_string(ndr, "printer_name", r->printer_name);
4979         }
4980         ndr->depth--;
4981         ndr_print_ptr(ndr, "server_name", r->server_name);
4982         ndr->depth++;
4983         if (r->server_name) {
4984                 ndr_print_string(ndr, "server_name", r->server_name);
4985         }
4986         ndr->depth--;
4987         ndr_print_ptr(ndr, "user_name", r->user_name);
4988         ndr->depth++;
4989         if (r->user_name) {
4990                 ndr_print_string(ndr, "user_name", r->user_name);
4991         }
4992         ndr->depth--;
4993         ndr_print_ptr(ndr, "document_name", r->document_name);
4994         ndr->depth++;
4995         if (r->document_name) {
4996                 ndr_print_string(ndr, "document_name", r->document_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5000         ndr->depth++;
5001         if (r->notify_name) {
5002                 ndr_print_string(ndr, "notify_name", r->notify_name);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "data_type", r->data_type);
5006         ndr->depth++;
5007         if (r->data_type) {
5008                 ndr_print_string(ndr, "data_type", r->data_type);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5012         ndr->depth++;
5013         if (r->print_processor) {
5014                 ndr_print_string(ndr, "print_processor", r->print_processor);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "parameters", r->parameters);
5018         ndr->depth++;
5019         if (r->parameters) {
5020                 ndr_print_string(ndr, "parameters", r->parameters);
5021         }
5022         ndr->depth--;
5023         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5024         ndr->depth++;
5025         if (r->driver_name) {
5026                 ndr_print_string(ndr, "driver_name", r->driver_name);
5027         }
5028         ndr->depth--;
5029         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5030         ndr_print_ptr(ndr, "text_status", r->text_status);
5031         ndr->depth++;
5032         if (r->text_status) {
5033                 ndr_print_string(ndr, "text_status", r->text_status);
5034         }
5035         ndr->depth--;
5036         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5037         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5038         ndr_print_uint32(ndr, "priority", r->priority);
5039         ndr_print_uint32(ndr, "position", r->position);
5040         ndr_print_uint32(ndr, "start_time", r->start_time);
5041         ndr_print_uint32(ndr, "until_time", r->until_time);
5042         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5043         ndr_print_uint32(ndr, "size", r->size);
5044         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5045         ndr_print_uint32(ndr, "time", r->time);
5046         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5047         ndr->depth--;
5048 }
5049
5050 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5051 {
5052         if (ndr_flags & NDR_SCALARS) {
5053                 NDR_CHECK(ndr_push_align(ndr, 4));
5054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5057                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5067                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5074                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5078         }
5079         if (ndr_flags & NDR_BUFFERS) {
5080                 if (r->printer_name) {
5081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5085                 }
5086                 if (r->server_name) {
5087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5091                 }
5092                 if (r->user_name) {
5093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5097                 }
5098                 if (r->document_name) {
5099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5103                 }
5104                 if (r->notify_name) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5109                 }
5110                 if (r->data_type) {
5111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5115                 }
5116                 if (r->print_processor) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5121                 }
5122                 if (r->parameters) {
5123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5127                 }
5128                 if (r->driver_name) {
5129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5133                 }
5134                 if (r->text_status) {
5135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5139                 }
5140         }
5141         return NDR_ERR_SUCCESS;
5142 }
5143
5144 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5145 {
5146         uint32_t _ptr_printer_name;
5147         TALLOC_CTX *_mem_save_printer_name_0;
5148         uint32_t _ptr_server_name;
5149         TALLOC_CTX *_mem_save_server_name_0;
5150         uint32_t _ptr_user_name;
5151         TALLOC_CTX *_mem_save_user_name_0;
5152         uint32_t _ptr_document_name;
5153         TALLOC_CTX *_mem_save_document_name_0;
5154         uint32_t _ptr_notify_name;
5155         TALLOC_CTX *_mem_save_notify_name_0;
5156         uint32_t _ptr_data_type;
5157         TALLOC_CTX *_mem_save_data_type_0;
5158         uint32_t _ptr_print_processor;
5159         TALLOC_CTX *_mem_save_print_processor_0;
5160         uint32_t _ptr_parameters;
5161         TALLOC_CTX *_mem_save_parameters_0;
5162         uint32_t _ptr_driver_name;
5163         TALLOC_CTX *_mem_save_driver_name_0;
5164         uint32_t _ptr_text_status;
5165         TALLOC_CTX *_mem_save_text_status_0;
5166         if (ndr_flags & NDR_SCALARS) {
5167                 NDR_CHECK(ndr_pull_align(ndr, 4));
5168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5170                 if (_ptr_printer_name) {
5171                         NDR_PULL_ALLOC(ndr, r->printer_name);
5172                 } else {
5173                         r->printer_name = NULL;
5174                 }
5175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5176                 if (_ptr_server_name) {
5177                         NDR_PULL_ALLOC(ndr, r->server_name);
5178                 } else {
5179                         r->server_name = NULL;
5180                 }
5181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5182                 if (_ptr_user_name) {
5183                         NDR_PULL_ALLOC(ndr, r->user_name);
5184                 } else {
5185                         r->user_name = NULL;
5186                 }
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5188                 if (_ptr_document_name) {
5189                         NDR_PULL_ALLOC(ndr, r->document_name);
5190                 } else {
5191                         r->document_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5194                 if (_ptr_notify_name) {
5195                         NDR_PULL_ALLOC(ndr, r->notify_name);
5196                 } else {
5197                         r->notify_name = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5200                 if (_ptr_data_type) {
5201                         NDR_PULL_ALLOC(ndr, r->data_type);
5202                 } else {
5203                         r->data_type = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5206                 if (_ptr_print_processor) {
5207                         NDR_PULL_ALLOC(ndr, r->print_processor);
5208                 } else {
5209                         r->print_processor = NULL;
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5212                 if (_ptr_parameters) {
5213                         NDR_PULL_ALLOC(ndr, r->parameters);
5214                 } else {
5215                         r->parameters = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5218                 if (_ptr_driver_name) {
5219                         NDR_PULL_ALLOC(ndr, r->driver_name);
5220                 } else {
5221                         r->driver_name = NULL;
5222                 }
5223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5225                 if (_ptr_text_status) {
5226                         NDR_PULL_ALLOC(ndr, r->text_status);
5227                 } else {
5228                         r->text_status = NULL;
5229                 }
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5231                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5238                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5240                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5242         }
5243         if (ndr_flags & NDR_BUFFERS) {
5244                 if (r->printer_name) {
5245                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5246                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5247                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5248                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5249                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5250                                 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));
5251                         }
5252                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5253                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5254                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5255                 }
5256                 if (r->server_name) {
5257                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5258                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5259                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5260                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5261                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5262                                 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));
5263                         }
5264                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5265                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5266                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5267                 }
5268                 if (r->user_name) {
5269                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5270                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5272                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5273                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5274                                 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));
5275                         }
5276                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5277                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5279                 }
5280                 if (r->document_name) {
5281                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5282                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5283                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5284                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5285                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5286                                 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));
5287                         }
5288                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5289                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5290                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5291                 }
5292                 if (r->notify_name) {
5293                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5294                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5295                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5296                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5297                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5298                                 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));
5299                         }
5300                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5301                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5303                 }
5304                 if (r->data_type) {
5305                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5306                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5307                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5308                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5309                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5310                                 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));
5311                         }
5312                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5313                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5314                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5315                 }
5316                 if (r->print_processor) {
5317                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5318                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5321                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5322                                 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));
5323                         }
5324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5325                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5327                 }
5328                 if (r->parameters) {
5329                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5330                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5333                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5334                                 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));
5335                         }
5336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5339                 }
5340                 if (r->driver_name) {
5341                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5342                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5344                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5345                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5346                                 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));
5347                         }
5348                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5349                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5351                 }
5352                 if (r->text_status) {
5353                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5354                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5357                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5358                                 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));
5359                         }
5360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5363                 }
5364         }
5365         return NDR_ERR_SUCCESS;
5366 }
5367
5368 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5369 {
5370         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5371         ndr->depth++;
5372         ndr_print_uint32(ndr, "job_id", r->job_id);
5373         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5374         ndr->depth++;
5375         if (r->printer_name) {
5376                 ndr_print_string(ndr, "printer_name", r->printer_name);
5377         }
5378         ndr->depth--;
5379         ndr_print_ptr(ndr, "server_name", r->server_name);
5380         ndr->depth++;
5381         if (r->server_name) {
5382                 ndr_print_string(ndr, "server_name", r->server_name);
5383         }
5384         ndr->depth--;
5385         ndr_print_ptr(ndr, "user_name", r->user_name);
5386         ndr->depth++;
5387         if (r->user_name) {
5388                 ndr_print_string(ndr, "user_name", r->user_name);
5389         }
5390         ndr->depth--;
5391         ndr_print_ptr(ndr, "document_name", r->document_name);
5392         ndr->depth++;
5393         if (r->document_name) {
5394                 ndr_print_string(ndr, "document_name", r->document_name);
5395         }
5396         ndr->depth--;
5397         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5398         ndr->depth++;
5399         if (r->notify_name) {
5400                 ndr_print_string(ndr, "notify_name", r->notify_name);
5401         }
5402         ndr->depth--;
5403         ndr_print_ptr(ndr, "data_type", r->data_type);
5404         ndr->depth++;
5405         if (r->data_type) {
5406                 ndr_print_string(ndr, "data_type", r->data_type);
5407         }
5408         ndr->depth--;
5409         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5410         ndr->depth++;
5411         if (r->print_processor) {
5412                 ndr_print_string(ndr, "print_processor", r->print_processor);
5413         }
5414         ndr->depth--;
5415         ndr_print_ptr(ndr, "parameters", r->parameters);
5416         ndr->depth++;
5417         if (r->parameters) {
5418                 ndr_print_string(ndr, "parameters", r->parameters);
5419         }
5420         ndr->depth--;
5421         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5422         ndr->depth++;
5423         if (r->driver_name) {
5424                 ndr_print_string(ndr, "driver_name", r->driver_name);
5425         }
5426         ndr->depth--;
5427         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5428         ndr_print_ptr(ndr, "text_status", r->text_status);
5429         ndr->depth++;
5430         if (r->text_status) {
5431                 ndr_print_string(ndr, "text_status", r->text_status);
5432         }
5433         ndr->depth--;
5434         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5435         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5436         ndr_print_uint32(ndr, "priority", r->priority);
5437         ndr_print_uint32(ndr, "position", r->position);
5438         ndr_print_uint32(ndr, "start_time", r->start_time);
5439         ndr_print_uint32(ndr, "until_time", r->until_time);
5440         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5441         ndr_print_uint32(ndr, "size", r->size);
5442         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5443         ndr_print_uint32(ndr, "time", r->time);
5444         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5445         ndr_print_uint32(ndr, "size_high", r->size_high);
5446         ndr->depth--;
5447 }
5448
5449 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5450 {
5451         if (ndr_flags & NDR_SCALARS) {
5452                 int level = ndr_push_get_switch_value(ndr, r);
5453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5454                 switch (level) {
5455                         case 1: {
5456                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5457                         break; }
5458
5459                         case 2: {
5460                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5461                         break; }
5462
5463                         case 3: {
5464                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5465                         break; }
5466
5467                         case 4: {
5468                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5469                         break; }
5470
5471                         default: {
5472                         break; }
5473
5474                 }
5475         }
5476         if (ndr_flags & NDR_BUFFERS) {
5477                 int level = ndr_push_get_switch_value(ndr, r);
5478                 switch (level) {
5479                         case 1:
5480                                 if (r->info1) {
5481                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5482                                 }
5483                         break;
5484
5485                         case 2:
5486                                 if (r->info2) {
5487                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5488                                 }
5489                         break;
5490
5491                         case 3:
5492                                 if (r->info3) {
5493                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5494                                 }
5495                         break;
5496
5497                         case 4:
5498                                 if (r->info4) {
5499                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5500                                 }
5501                         break;
5502
5503                         default:
5504                         break;
5505
5506                 }
5507         }
5508         return NDR_ERR_SUCCESS;
5509 }
5510
5511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5512 {
5513         int level;
5514         uint32_t _level;
5515         TALLOC_CTX *_mem_save_info1_0;
5516         TALLOC_CTX *_mem_save_info2_0;
5517         TALLOC_CTX *_mem_save_info3_0;
5518         TALLOC_CTX *_mem_save_info4_0;
5519         level = ndr_pull_get_switch_value(ndr, r);
5520         if (ndr_flags & NDR_SCALARS) {
5521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5522                 if (_level != level) {
5523                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5524                 }
5525                 switch (level) {
5526                         case 1: {
5527                                 uint32_t _ptr_info1;
5528                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5529                                 if (_ptr_info1) {
5530                                         NDR_PULL_ALLOC(ndr, r->info1);
5531                                 } else {
5532                                         r->info1 = NULL;
5533                                 }
5534                         break; }
5535
5536                         case 2: {
5537                                 uint32_t _ptr_info2;
5538                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5539                                 if (_ptr_info2) {
5540                                         NDR_PULL_ALLOC(ndr, r->info2);
5541                                 } else {
5542                                         r->info2 = NULL;
5543                                 }
5544                         break; }
5545
5546                         case 3: {
5547                                 uint32_t _ptr_info3;
5548                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5549                                 if (_ptr_info3) {
5550                                         NDR_PULL_ALLOC(ndr, r->info3);
5551                                 } else {
5552                                         r->info3 = NULL;
5553                                 }
5554                         break; }
5555
5556                         case 4: {
5557                                 uint32_t _ptr_info4;
5558                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5559                                 if (_ptr_info4) {
5560                                         NDR_PULL_ALLOC(ndr, r->info4);
5561                                 } else {
5562                                         r->info4 = NULL;
5563                                 }
5564                         break; }
5565
5566                         default: {
5567                         break; }
5568
5569                 }
5570         }
5571         if (ndr_flags & NDR_BUFFERS) {
5572                 switch (level) {
5573                         case 1:
5574                                 if (r->info1) {
5575                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5576                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5577                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5578                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5579                                 }
5580                         break;
5581
5582                         case 2:
5583                                 if (r->info2) {
5584                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5585                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5586                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5587                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5588                                 }
5589                         break;
5590
5591                         case 3:
5592                                 if (r->info3) {
5593                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5594                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5595                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5596                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5597                                 }
5598                         break;
5599
5600                         case 4:
5601                                 if (r->info4) {
5602                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5603                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5604                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5605                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5606                                 }
5607                         break;
5608
5609                         default:
5610                         break;
5611
5612                 }
5613         }
5614         return NDR_ERR_SUCCESS;
5615 }
5616
5617 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5618 {
5619         int level;
5620         level = ndr_print_get_switch_value(ndr, r);
5621         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5622         switch (level) {
5623                 case 1:
5624                         ndr_print_ptr(ndr, "info1", r->info1);
5625                         ndr->depth++;
5626                         if (r->info1) {
5627                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5628                         }
5629                         ndr->depth--;
5630                 break;
5631
5632                 case 2:
5633                         ndr_print_ptr(ndr, "info2", r->info2);
5634                         ndr->depth++;
5635                         if (r->info2) {
5636                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5637                         }
5638                         ndr->depth--;
5639                 break;
5640
5641                 case 3:
5642                         ndr_print_ptr(ndr, "info3", r->info3);
5643                         ndr->depth++;
5644                         if (r->info3) {
5645                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5646                         }
5647                         ndr->depth--;
5648                 break;
5649
5650                 case 4:
5651                         ndr_print_ptr(ndr, "info4", r->info4);
5652                         ndr->depth++;
5653                         if (r->info4) {
5654                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5655                         }
5656                         ndr->depth--;
5657                 break;
5658
5659                 default:
5660                 break;
5661
5662         }
5663 }
5664
5665 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5666 {
5667         if (ndr_flags & NDR_SCALARS) {
5668                 NDR_CHECK(ndr_push_align(ndr, 4));
5669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5670                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5671                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5672         }
5673         if (ndr_flags & NDR_BUFFERS) {
5674                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5675         }
5676         return NDR_ERR_SUCCESS;
5677 }
5678
5679 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5680 {
5681         if (ndr_flags & NDR_SCALARS) {
5682                 NDR_CHECK(ndr_pull_align(ndr, 4));
5683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5684                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5685                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5686         }
5687         if (ndr_flags & NDR_BUFFERS) {
5688                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5689         }
5690         return NDR_ERR_SUCCESS;
5691 }
5692
5693 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5694 {
5695         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5696         ndr->depth++;
5697         ndr_print_uint32(ndr, "level", r->level);
5698         ndr_print_set_switch_value(ndr, &r->info, r->level);
5699         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5700         ndr->depth--;
5701 }
5702
5703 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5704 {
5705         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5706         return NDR_ERR_SUCCESS;
5707 }
5708
5709 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5710 {
5711         uint32_t v;
5712         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5713         *r = v;
5714         return NDR_ERR_SUCCESS;
5715 }
5716
5717 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5718 {
5719         const char *val = NULL;
5720
5721         switch (r) {
5722                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5723                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5724                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5725                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5726                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5727                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5728                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5729                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5730                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5731         }
5732         ndr_print_enum(ndr, name, "ENUM", val, r);
5733 }
5734
5735 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5736 {
5737         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5738         return NDR_ERR_SUCCESS;
5739 }
5740
5741 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5742 {
5743         uint32_t v;
5744         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5745         *r = v;
5746         return NDR_ERR_SUCCESS;
5747 }
5748
5749 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5750 {
5751         const char *val = NULL;
5752
5753         switch (r) {
5754                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5755                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5756                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5757                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5758                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5759         }
5760         ndr_print_enum(ndr, name, "ENUM", val, r);
5761 }
5762
5763 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5764 {
5765         if (ndr_flags & NDR_SCALARS) {
5766                 NDR_CHECK(ndr_push_align(ndr, 4));
5767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5772                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5784                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5791                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5792                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5796         }
5797         if (ndr_flags & NDR_BUFFERS) {
5798                 if (r->servername) {
5799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5800                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5802                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5803                 }
5804                 if (r->printername) {
5805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5808                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5809                 }
5810         }
5811         return NDR_ERR_SUCCESS;
5812 }
5813
5814 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5815 {
5816         uint32_t _ptr_servername;
5817         TALLOC_CTX *_mem_save_servername_0;
5818         uint32_t _ptr_printername;
5819         TALLOC_CTX *_mem_save_printername_0;
5820         if (ndr_flags & NDR_SCALARS) {
5821                 NDR_CHECK(ndr_pull_align(ndr, 4));
5822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5823                 if (_ptr_servername) {
5824                         NDR_PULL_ALLOC(ndr, r->servername);
5825                 } else {
5826                         r->servername = NULL;
5827                 }
5828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5829                 if (_ptr_printername) {
5830                         NDR_PULL_ALLOC(ndr, r->printername);
5831                 } else {
5832                         r->printername = NULL;
5833                 }
5834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5837                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5849                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5856                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5857                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5861         }
5862         if (ndr_flags & NDR_BUFFERS) {
5863                 if (r->servername) {
5864                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5865                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5868                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5869                                 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));
5870                         }
5871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5874                 }
5875                 if (r->printername) {
5876                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5877                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5880                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5881                                 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));
5882                         }
5883                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5884                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5886                 }
5887         }
5888         return NDR_ERR_SUCCESS;
5889 }
5890
5891 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5892 {
5893         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5894         ndr->depth++;
5895         ndr_print_ptr(ndr, "servername", r->servername);
5896         ndr->depth++;
5897         if (r->servername) {
5898                 ndr_print_string(ndr, "servername", r->servername);
5899         }
5900         ndr->depth--;
5901         ndr_print_ptr(ndr, "printername", r->printername);
5902         ndr->depth++;
5903         if (r->printername) {
5904                 ndr_print_string(ndr, "printername", r->printername);
5905         }
5906         ndr->depth--;
5907         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5908         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5909         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5910         ndr_print_spoolss_Time(ndr, "time", &r->time);
5911         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5912         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5913         ndr_print_uint32(ndr, "version", r->version);
5914         ndr_print_uint32(ndr, "free_build", r->free_build);
5915         ndr_print_uint32(ndr, "spooling", r->spooling);
5916         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5917         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5918         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5919         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5920         ndr_print_uint32(ndr, "job_error", r->job_error);
5921         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5922         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5923         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5924         ndr_print_uint32(ndr, "change_id", r->change_id);
5925         ndr_print_WERROR(ndr, "last_error", r->last_error);
5926         ndr_print_uint32(ndr, "status", r->status);
5927         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5928         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5929         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5930         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5931         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5932         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5933         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5934         ndr->depth--;
5935 }
5936
5937 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5938 {
5939         if (ndr_flags & NDR_SCALARS) {
5940                 NDR_CHECK(ndr_push_align(ndr, 4));
5941                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5945         }
5946         if (ndr_flags & NDR_BUFFERS) {
5947                 if (r->name) {
5948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5952                 }
5953                 if (r->description) {
5954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5958                 }
5959                 if (r->comment) {
5960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5964                 }
5965         }
5966         return NDR_ERR_SUCCESS;
5967 }
5968
5969 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5970 {
5971         uint32_t _ptr_name;
5972         TALLOC_CTX *_mem_save_name_0;
5973         uint32_t _ptr_description;
5974         TALLOC_CTX *_mem_save_description_0;
5975         uint32_t _ptr_comment;
5976         TALLOC_CTX *_mem_save_comment_0;
5977         if (ndr_flags & NDR_SCALARS) {
5978                 NDR_CHECK(ndr_pull_align(ndr, 4));
5979                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5980                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5981                 if (_ptr_name) {
5982                         NDR_PULL_ALLOC(ndr, r->name);
5983                 } else {
5984                         r->name = NULL;
5985                 }
5986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5987                 if (_ptr_description) {
5988                         NDR_PULL_ALLOC(ndr, r->description);
5989                 } else {
5990                         r->description = NULL;
5991                 }
5992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5993                 if (_ptr_comment) {
5994                         NDR_PULL_ALLOC(ndr, r->comment);
5995                 } else {
5996                         r->comment = NULL;
5997                 }
5998         }
5999         if (ndr_flags & NDR_BUFFERS) {
6000                 if (r->name) {
6001                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6002                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6003                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6004                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6005                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6006                                 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));
6007                         }
6008                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6009                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6011                 }
6012                 if (r->description) {
6013                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6014                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6015                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6016                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6017                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6018                                 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));
6019                         }
6020                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6021                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6022                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6023                 }
6024                 if (r->comment) {
6025                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6026                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6027                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6028                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6029                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6030                                 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));
6031                         }
6032                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6033                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6034                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6035                 }
6036         }
6037         return NDR_ERR_SUCCESS;
6038 }
6039
6040 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6041 {
6042         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6043         ndr->depth++;
6044         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6045         ndr_print_ptr(ndr, "name", r->name);
6046         ndr->depth++;
6047         if (r->name) {
6048                 ndr_print_string(ndr, "name", r->name);
6049         }
6050         ndr->depth--;
6051         ndr_print_ptr(ndr, "description", r->description);
6052         ndr->depth++;
6053         if (r->description) {
6054                 ndr_print_string(ndr, "description", r->description);
6055         }
6056         ndr->depth--;
6057         ndr_print_ptr(ndr, "comment", r->comment);
6058         ndr->depth++;
6059         if (r->comment) {
6060                 ndr_print_string(ndr, "comment", r->comment);
6061         }
6062         ndr->depth--;
6063         ndr->depth--;
6064 }
6065
6066 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6067 {
6068         if (ndr_flags & NDR_SCALARS) {
6069                 NDR_CHECK(ndr_push_align(ndr, 4));
6070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6083                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6088                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6091         }
6092         if (ndr_flags & NDR_BUFFERS) {
6093                 if (r->servername) {
6094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6098                 }
6099                 if (r->printername) {
6100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6104                 }
6105                 if (r->sharename) {
6106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6109                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6110                 }
6111                 if (r->portname) {
6112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6115                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6116                 }
6117                 if (r->drivername) {
6118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6121                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6122                 }
6123                 if (r->comment) {
6124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6126                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6127                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6128                 }
6129                 if (r->location) {
6130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6132                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6133                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6134                 }
6135                 if (r->devmode) {
6136                         {
6137                                 struct ndr_push *_ndr_devmode;
6138                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6139                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6140                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6141                         }
6142                 }
6143                 if (r->sepfile) {
6144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6148                 }
6149                 if (r->printprocessor) {
6150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6153                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6154                 }
6155                 if (r->datatype) {
6156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6160                 }
6161                 if (r->parameters) {
6162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6164                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6165                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6166                 }
6167                 if (r->secdesc) {
6168                         {
6169                                 struct ndr_push *_ndr_secdesc;
6170                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6171                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6172                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6173                         }
6174                 }
6175         }
6176         return NDR_ERR_SUCCESS;
6177 }
6178
6179 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6180 {
6181         uint32_t _ptr_servername;
6182         TALLOC_CTX *_mem_save_servername_0;
6183         uint32_t _ptr_printername;
6184         TALLOC_CTX *_mem_save_printername_0;
6185         uint32_t _ptr_sharename;
6186         TALLOC_CTX *_mem_save_sharename_0;
6187         uint32_t _ptr_portname;
6188         TALLOC_CTX *_mem_save_portname_0;
6189         uint32_t _ptr_drivername;
6190         TALLOC_CTX *_mem_save_drivername_0;
6191         uint32_t _ptr_comment;
6192         TALLOC_CTX *_mem_save_comment_0;
6193         uint32_t _ptr_location;
6194         TALLOC_CTX *_mem_save_location_0;
6195         uint32_t _ptr_devmode;
6196         TALLOC_CTX *_mem_save_devmode_0;
6197         uint32_t _ptr_sepfile;
6198         TALLOC_CTX *_mem_save_sepfile_0;
6199         uint32_t _ptr_printprocessor;
6200         TALLOC_CTX *_mem_save_printprocessor_0;
6201         uint32_t _ptr_datatype;
6202         TALLOC_CTX *_mem_save_datatype_0;
6203         uint32_t _ptr_parameters;
6204         TALLOC_CTX *_mem_save_parameters_0;
6205         uint32_t _ptr_secdesc;
6206         TALLOC_CTX *_mem_save_secdesc_0;
6207         if (ndr_flags & NDR_SCALARS) {
6208                 NDR_CHECK(ndr_pull_align(ndr, 4));
6209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6210                 if (_ptr_servername) {
6211                         NDR_PULL_ALLOC(ndr, r->servername);
6212                 } else {
6213                         r->servername = NULL;
6214                 }
6215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6216                 if (_ptr_printername) {
6217                         NDR_PULL_ALLOC(ndr, r->printername);
6218                 } else {
6219                         r->printername = NULL;
6220                 }
6221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6222                 if (_ptr_sharename) {
6223                         NDR_PULL_ALLOC(ndr, r->sharename);
6224                 } else {
6225                         r->sharename = NULL;
6226                 }
6227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6228                 if (_ptr_portname) {
6229                         NDR_PULL_ALLOC(ndr, r->portname);
6230                 } else {
6231                         r->portname = NULL;
6232                 }
6233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6234                 if (_ptr_drivername) {
6235                         NDR_PULL_ALLOC(ndr, r->drivername);
6236                 } else {
6237                         r->drivername = NULL;
6238                 }
6239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6240                 if (_ptr_comment) {
6241                         NDR_PULL_ALLOC(ndr, r->comment);
6242                 } else {
6243                         r->comment = NULL;
6244                 }
6245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6246                 if (_ptr_location) {
6247                         NDR_PULL_ALLOC(ndr, r->location);
6248                 } else {
6249                         r->location = NULL;
6250                 }
6251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6252                 if (_ptr_devmode) {
6253                         NDR_PULL_ALLOC(ndr, r->devmode);
6254                 } else {
6255                         r->devmode = NULL;
6256                 }
6257                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6258                 if (_ptr_sepfile) {
6259                         NDR_PULL_ALLOC(ndr, r->sepfile);
6260                 } else {
6261                         r->sepfile = NULL;
6262                 }
6263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6264                 if (_ptr_printprocessor) {
6265                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6266                 } else {
6267                         r->printprocessor = NULL;
6268                 }
6269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6270                 if (_ptr_datatype) {
6271                         NDR_PULL_ALLOC(ndr, r->datatype);
6272                 } else {
6273                         r->datatype = NULL;
6274                 }
6275                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6276                 if (_ptr_parameters) {
6277                         NDR_PULL_ALLOC(ndr, r->parameters);
6278                 } else {
6279                         r->parameters = NULL;
6280                 }
6281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6282                 if (_ptr_secdesc) {
6283                         NDR_PULL_ALLOC(ndr, r->secdesc);
6284                 } else {
6285                         r->secdesc = NULL;
6286                 }
6287                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6288                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6292                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6295         }
6296         if (ndr_flags & NDR_BUFFERS) {
6297                 if (r->servername) {
6298                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6299                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6300                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6301                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6302                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6303                                 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));
6304                         }
6305                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6306                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6308                 }
6309                 if (r->printername) {
6310                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6311                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6312                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6313                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6314                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6315                                 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));
6316                         }
6317                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6318                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6320                 }
6321                 if (r->sharename) {
6322                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6323                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6326                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6327                                 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));
6328                         }
6329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6332                 }
6333                 if (r->portname) {
6334                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6338                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6339                                 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));
6340                         }
6341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6344                 }
6345                 if (r->drivername) {
6346                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6347                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6350                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6351                                 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));
6352                         }
6353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6356                 }
6357                 if (r->comment) {
6358                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6362                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6363                                 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));
6364                         }
6365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6368                 }
6369                 if (r->location) {
6370                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6374                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6375                                 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));
6376                         }
6377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6380                 }
6381                 if (r->devmode) {
6382                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6384                         {
6385                                 struct ndr_pull *_ndr_devmode;
6386                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6387                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6388                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6389                         }
6390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6391                 }
6392                 if (r->sepfile) {
6393                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6394                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6397                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6398                                 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));
6399                         }
6400                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6403                 }
6404                 if (r->printprocessor) {
6405                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6406                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6407                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6408                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6409                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6410                                 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));
6411                         }
6412                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6413                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6415                 }
6416                 if (r->datatype) {
6417                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6418                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6421                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6422                                 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));
6423                         }
6424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6427                 }
6428                 if (r->parameters) {
6429                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6433                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6434                                 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));
6435                         }
6436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6439                 }
6440                 if (r->secdesc) {
6441                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6443                         {
6444                                 struct ndr_pull *_ndr_secdesc;
6445                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6446                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6447                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6448                         }
6449                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6450                 }
6451         }
6452         return NDR_ERR_SUCCESS;
6453 }
6454
6455 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6456 {
6457         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6458         ndr->depth++;
6459         ndr_print_ptr(ndr, "servername", r->servername);
6460         ndr->depth++;
6461         if (r->servername) {
6462                 ndr_print_string(ndr, "servername", r->servername);
6463         }
6464         ndr->depth--;
6465         ndr_print_ptr(ndr, "printername", r->printername);
6466         ndr->depth++;
6467         if (r->printername) {
6468                 ndr_print_string(ndr, "printername", r->printername);
6469         }
6470         ndr->depth--;
6471         ndr_print_ptr(ndr, "sharename", r->sharename);
6472         ndr->depth++;
6473         if (r->sharename) {
6474                 ndr_print_string(ndr, "sharename", r->sharename);
6475         }
6476         ndr->depth--;
6477         ndr_print_ptr(ndr, "portname", r->portname);
6478         ndr->depth++;
6479         if (r->portname) {
6480                 ndr_print_string(ndr, "portname", r->portname);
6481         }
6482         ndr->depth--;
6483         ndr_print_ptr(ndr, "drivername", r->drivername);
6484         ndr->depth++;
6485         if (r->drivername) {
6486                 ndr_print_string(ndr, "drivername", r->drivername);
6487         }
6488         ndr->depth--;
6489         ndr_print_ptr(ndr, "comment", r->comment);
6490         ndr->depth++;
6491         if (r->comment) {
6492                 ndr_print_string(ndr, "comment", r->comment);
6493         }
6494         ndr->depth--;
6495         ndr_print_ptr(ndr, "location", r->location);
6496         ndr->depth++;
6497         if (r->location) {
6498                 ndr_print_string(ndr, "location", r->location);
6499         }
6500         ndr->depth--;
6501         ndr_print_ptr(ndr, "devmode", r->devmode);
6502         ndr->depth++;
6503         if (r->devmode) {
6504                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6505         }
6506         ndr->depth--;
6507         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6508         ndr->depth++;
6509         if (r->sepfile) {
6510                 ndr_print_string(ndr, "sepfile", r->sepfile);
6511         }
6512         ndr->depth--;
6513         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6514         ndr->depth++;
6515         if (r->printprocessor) {
6516                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6517         }
6518         ndr->depth--;
6519         ndr_print_ptr(ndr, "datatype", r->datatype);
6520         ndr->depth++;
6521         if (r->datatype) {
6522                 ndr_print_string(ndr, "datatype", r->datatype);
6523         }
6524         ndr->depth--;
6525         ndr_print_ptr(ndr, "parameters", r->parameters);
6526         ndr->depth++;
6527         if (r->parameters) {
6528                 ndr_print_string(ndr, "parameters", r->parameters);
6529         }
6530         ndr->depth--;
6531         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6532         ndr->depth++;
6533         if (r->secdesc) {
6534                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6535         }
6536         ndr->depth--;
6537         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6538         ndr_print_uint32(ndr, "priority", r->priority);
6539         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6540         ndr_print_uint32(ndr, "starttime", r->starttime);
6541         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6542         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6543         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6544         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6545         ndr->depth--;
6546 }
6547
6548 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6549 {
6550         if (ndr_flags & NDR_SCALARS) {
6551                 NDR_CHECK(ndr_push_align(ndr, 4));
6552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6553         }
6554         if (ndr_flags & NDR_BUFFERS) {
6555         }
6556         return NDR_ERR_SUCCESS;
6557 }
6558
6559 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6560 {
6561         if (ndr_flags & NDR_SCALARS) {
6562                 NDR_CHECK(ndr_pull_align(ndr, 4));
6563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6564         }
6565         if (ndr_flags & NDR_BUFFERS) {
6566         }
6567         return NDR_ERR_SUCCESS;
6568 }
6569
6570 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6571 {
6572         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6573         ndr->depth++;
6574         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6575         ndr->depth--;
6576 }
6577
6578 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6579 {
6580         if (ndr_flags & NDR_SCALARS) {
6581                 NDR_CHECK(ndr_push_align(ndr, 4));
6582                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6583                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6584                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6585         }
6586         if (ndr_flags & NDR_BUFFERS) {
6587                 if (r->printername) {
6588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6592                 }
6593                 if (r->servername) {
6594                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6595                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6597                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6598                 }
6599         }
6600         return NDR_ERR_SUCCESS;
6601 }
6602
6603 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6604 {
6605         uint32_t _ptr_printername;
6606         TALLOC_CTX *_mem_save_printername_0;
6607         uint32_t _ptr_servername;
6608         TALLOC_CTX *_mem_save_servername_0;
6609         if (ndr_flags & NDR_SCALARS) {
6610                 NDR_CHECK(ndr_pull_align(ndr, 4));
6611                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6612                 if (_ptr_printername) {
6613                         NDR_PULL_ALLOC(ndr, r->printername);
6614                 } else {
6615                         r->printername = NULL;
6616                 }
6617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6618                 if (_ptr_servername) {
6619                         NDR_PULL_ALLOC(ndr, r->servername);
6620                 } else {
6621                         r->servername = NULL;
6622                 }
6623                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6624         }
6625         if (ndr_flags & NDR_BUFFERS) {
6626                 if (r->printername) {
6627                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6628                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6629                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6630                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6631                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6632                                 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));
6633                         }
6634                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6635                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6637                 }
6638                 if (r->servername) {
6639                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6640                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6641                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6642                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6643                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6644                                 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));
6645                         }
6646                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6647                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6648                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6649                 }
6650         }
6651         return NDR_ERR_SUCCESS;
6652 }
6653
6654 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6655 {
6656         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6657         ndr->depth++;
6658         ndr_print_ptr(ndr, "printername", r->printername);
6659         ndr->depth++;
6660         if (r->printername) {
6661                 ndr_print_string(ndr, "printername", r->printername);
6662         }
6663         ndr->depth--;
6664         ndr_print_ptr(ndr, "servername", r->servername);
6665         ndr->depth++;
6666         if (r->servername) {
6667                 ndr_print_string(ndr, "servername", r->servername);
6668         }
6669         ndr->depth--;
6670         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6671         ndr->depth--;
6672 }
6673
6674 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6675 {
6676         if (ndr_flags & NDR_SCALARS) {
6677                 NDR_CHECK(ndr_push_align(ndr, 4));
6678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6680                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6683         }
6684         if (ndr_flags & NDR_BUFFERS) {
6685                 if (r->printername) {
6686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6690                 }
6691                 if (r->portname) {
6692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6696                 }
6697         }
6698         return NDR_ERR_SUCCESS;
6699 }
6700
6701 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6702 {
6703         uint32_t _ptr_printername;
6704         TALLOC_CTX *_mem_save_printername_0;
6705         uint32_t _ptr_portname;
6706         TALLOC_CTX *_mem_save_portname_0;
6707         if (ndr_flags & NDR_SCALARS) {
6708                 NDR_CHECK(ndr_pull_align(ndr, 4));
6709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6710                 if (_ptr_printername) {
6711                         NDR_PULL_ALLOC(ndr, r->printername);
6712                 } else {
6713                         r->printername = NULL;
6714                 }
6715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6716                 if (_ptr_portname) {
6717                         NDR_PULL_ALLOC(ndr, r->portname);
6718                 } else {
6719                         r->portname = NULL;
6720                 }
6721                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6724         }
6725         if (ndr_flags & NDR_BUFFERS) {
6726                 if (r->printername) {
6727                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6728                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6731                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6732                                 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));
6733                         }
6734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6737                 }
6738                 if (r->portname) {
6739                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6740                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6743                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6744                                 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));
6745                         }
6746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6749                 }
6750         }
6751         return NDR_ERR_SUCCESS;
6752 }
6753
6754 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6755 {
6756         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6757         ndr->depth++;
6758         ndr_print_ptr(ndr, "printername", r->printername);
6759         ndr->depth++;
6760         if (r->printername) {
6761                 ndr_print_string(ndr, "printername", r->printername);
6762         }
6763         ndr->depth--;
6764         ndr_print_ptr(ndr, "portname", r->portname);
6765         ndr->depth++;
6766         if (r->portname) {
6767                 ndr_print_string(ndr, "portname", r->portname);
6768         }
6769         ndr->depth--;
6770         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6771         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6772         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6773         ndr->depth--;
6774 }
6775
6776 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6777 {
6778         if (ndr_flags & NDR_SCALARS) {
6779                 NDR_CHECK(ndr_push_align(ndr, 4));
6780                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6781         }
6782         if (ndr_flags & NDR_BUFFERS) {
6783         }
6784         return NDR_ERR_SUCCESS;
6785 }
6786
6787 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6788 {
6789         if (ndr_flags & NDR_SCALARS) {
6790                 NDR_CHECK(ndr_pull_align(ndr, 4));
6791                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6792         }
6793         if (ndr_flags & NDR_BUFFERS) {
6794         }
6795         return NDR_ERR_SUCCESS;
6796 }
6797
6798 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6799 {
6800         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6801         ndr->depth++;
6802         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6803         ndr->depth--;
6804 }
6805
6806 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6807 {
6808         if (ndr_flags & NDR_SCALARS) {
6809                 NDR_CHECK(ndr_push_align(ndr, 4));
6810                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6811                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6812         }
6813         if (ndr_flags & NDR_BUFFERS) {
6814                 if (r->guid) {
6815                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6818                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6819                 }
6820         }
6821         return NDR_ERR_SUCCESS;
6822 }
6823
6824 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6825 {
6826         uint32_t _ptr_guid;
6827         TALLOC_CTX *_mem_save_guid_0;
6828         if (ndr_flags & NDR_SCALARS) {
6829                 NDR_CHECK(ndr_pull_align(ndr, 4));
6830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6831                 if (_ptr_guid) {
6832                         NDR_PULL_ALLOC(ndr, r->guid);
6833                 } else {
6834                         r->guid = NULL;
6835                 }
6836                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6837         }
6838         if (ndr_flags & NDR_BUFFERS) {
6839                 if (r->guid) {
6840                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6841                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6842                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6843                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6844                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6845                                 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));
6846                         }
6847                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6848                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6849                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6850                 }
6851         }
6852         return NDR_ERR_SUCCESS;
6853 }
6854
6855 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6856 {
6857         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6858         ndr->depth++;
6859         ndr_print_ptr(ndr, "guid", r->guid);
6860         ndr->depth++;
6861         if (r->guid) {
6862                 ndr_print_string(ndr, "guid", r->guid);
6863         }
6864         ndr->depth--;
6865         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6866         ndr->depth--;
6867 }
6868
6869 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6870 {
6871         if (ndr_flags & NDR_SCALARS) {
6872                 int level = ndr_push_get_switch_value(ndr, r);
6873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6874                 switch (level) {
6875                         case 0: {
6876                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6877                         break; }
6878
6879                         case 1: {
6880                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6881                         break; }
6882
6883                         case 2: {
6884                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6885                         break; }
6886
6887                         case 3: {
6888                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6889                         break; }
6890
6891                         case 4: {
6892                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6893                         break; }
6894
6895                         case 5: {
6896                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6897                         break; }
6898
6899                         case 6: {
6900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6901                         break; }
6902
6903                         case 7: {
6904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6905                         break; }
6906
6907                         case 8: {
6908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6909                         break; }
6910
6911                         case 9: {
6912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6913                         break; }
6914
6915                         default: {
6916                         break; }
6917
6918                 }
6919         }
6920         if (ndr_flags & NDR_BUFFERS) {
6921                 int level = ndr_push_get_switch_value(ndr, r);
6922                 switch (level) {
6923                         case 0:
6924                                 if (r->info0) {
6925                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6926                                 }
6927                         break;
6928
6929                         case 1:
6930                                 if (r->info1) {
6931                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6932                                 }
6933                         break;
6934
6935                         case 2:
6936                                 if (r->info2) {
6937                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6938                                 }
6939                         break;
6940
6941                         case 3:
6942                                 if (r->info3) {
6943                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6944                                 }
6945                         break;
6946
6947                         case 4:
6948                                 if (r->info4) {
6949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6950                                 }
6951                         break;
6952
6953                         case 5:
6954                                 if (r->info5) {
6955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6956                                 }
6957                         break;
6958
6959                         case 6:
6960                                 if (r->info6) {
6961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6962                                 }
6963                         break;
6964
6965                         case 7:
6966                                 if (r->info7) {
6967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6968                                 }
6969                         break;
6970
6971                         case 8:
6972                                 if (r->info8) {
6973                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6974                                 }
6975                         break;
6976
6977                         case 9:
6978                                 if (r->info9) {
6979                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6980                                 }
6981                         break;
6982
6983                         default:
6984                         break;
6985
6986                 }
6987         }
6988         return NDR_ERR_SUCCESS;
6989 }
6990
6991 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6992 {
6993         int level;
6994         uint32_t _level;
6995         TALLOC_CTX *_mem_save_info0_0;
6996         TALLOC_CTX *_mem_save_info1_0;
6997         TALLOC_CTX *_mem_save_info2_0;
6998         TALLOC_CTX *_mem_save_info3_0;
6999         TALLOC_CTX *_mem_save_info4_0;
7000         TALLOC_CTX *_mem_save_info5_0;
7001         TALLOC_CTX *_mem_save_info6_0;
7002         TALLOC_CTX *_mem_save_info7_0;
7003         TALLOC_CTX *_mem_save_info8_0;
7004         TALLOC_CTX *_mem_save_info9_0;
7005         level = ndr_pull_get_switch_value(ndr, r);
7006         if (ndr_flags & NDR_SCALARS) {
7007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7008                 if (_level != level) {
7009                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7010                 }
7011                 switch (level) {
7012                         case 0: {
7013                                 uint32_t _ptr_info0;
7014                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7015                                 if (_ptr_info0) {
7016                                         NDR_PULL_ALLOC(ndr, r->info0);
7017                                 } else {
7018                                         r->info0 = NULL;
7019                                 }
7020                         break; }
7021
7022                         case 1: {
7023                                 uint32_t _ptr_info1;
7024                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7025                                 if (_ptr_info1) {
7026                                         NDR_PULL_ALLOC(ndr, r->info1);
7027                                 } else {
7028                                         r->info1 = NULL;
7029                                 }
7030                         break; }
7031
7032                         case 2: {
7033                                 uint32_t _ptr_info2;
7034                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7035                                 if (_ptr_info2) {
7036                                         NDR_PULL_ALLOC(ndr, r->info2);
7037                                 } else {
7038                                         r->info2 = NULL;
7039                                 }
7040                         break; }
7041
7042                         case 3: {
7043                                 uint32_t _ptr_info3;
7044                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7045                                 if (_ptr_info3) {
7046                                         NDR_PULL_ALLOC(ndr, r->info3);
7047                                 } else {
7048                                         r->info3 = NULL;
7049                                 }
7050                         break; }
7051
7052                         case 4: {
7053                                 uint32_t _ptr_info4;
7054                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7055                                 if (_ptr_info4) {
7056                                         NDR_PULL_ALLOC(ndr, r->info4);
7057                                 } else {
7058                                         r->info4 = NULL;
7059                                 }
7060                         break; }
7061
7062                         case 5: {
7063                                 uint32_t _ptr_info5;
7064                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7065                                 if (_ptr_info5) {
7066                                         NDR_PULL_ALLOC(ndr, r->info5);
7067                                 } else {
7068                                         r->info5 = NULL;
7069                                 }
7070                         break; }
7071
7072                         case 6: {
7073                                 uint32_t _ptr_info6;
7074                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7075                                 if (_ptr_info6) {
7076                                         NDR_PULL_ALLOC(ndr, r->info6);
7077                                 } else {
7078                                         r->info6 = NULL;
7079                                 }
7080                         break; }
7081
7082                         case 7: {
7083                                 uint32_t _ptr_info7;
7084                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7085                                 if (_ptr_info7) {
7086                                         NDR_PULL_ALLOC(ndr, r->info7);
7087                                 } else {
7088                                         r->info7 = NULL;
7089                                 }
7090                         break; }
7091
7092                         case 8: {
7093                                 uint32_t _ptr_info8;
7094                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7095                                 if (_ptr_info8) {
7096                                         NDR_PULL_ALLOC(ndr, r->info8);
7097                                 } else {
7098                                         r->info8 = NULL;
7099                                 }
7100                         break; }
7101
7102                         case 9: {
7103                                 uint32_t _ptr_info9;
7104                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7105                                 if (_ptr_info9) {
7106                                         NDR_PULL_ALLOC(ndr, r->info9);
7107                                 } else {
7108                                         r->info9 = NULL;
7109                                 }
7110                         break; }
7111
7112                         default: {
7113                         break; }
7114
7115                 }
7116         }
7117         if (ndr_flags & NDR_BUFFERS) {
7118                 switch (level) {
7119                         case 0:
7120                                 if (r->info0) {
7121                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7123                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7125                                 }
7126                         break;
7127
7128                         case 1:
7129                                 if (r->info1) {
7130                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7131                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7132                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7133                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7134                                 }
7135                         break;
7136
7137                         case 2:
7138                                 if (r->info2) {
7139                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7140                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7141                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7142                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7143                                 }
7144                         break;
7145
7146                         case 3:
7147                                 if (r->info3) {
7148                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7149                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7150                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7151                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7152                                 }
7153                         break;
7154
7155                         case 4:
7156                                 if (r->info4) {
7157                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7158                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7159                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7160                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7161                                 }
7162                         break;
7163
7164                         case 5:
7165                                 if (r->info5) {
7166                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7167                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7168                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7169                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7170                                 }
7171                         break;
7172
7173                         case 6:
7174                                 if (r->info6) {
7175                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7176                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7177                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7178                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7179                                 }
7180                         break;
7181
7182                         case 7:
7183                                 if (r->info7) {
7184                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7185                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7186                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7187                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7188                                 }
7189                         break;
7190
7191                         case 8:
7192                                 if (r->info8) {
7193                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7194                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7195                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7196                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7197                                 }
7198                         break;
7199
7200                         case 9:
7201                                 if (r->info9) {
7202                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7203                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7204                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7205                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7206                                 }
7207                         break;
7208
7209                         default:
7210                         break;
7211
7212                 }
7213         }
7214         return NDR_ERR_SUCCESS;
7215 }
7216
7217 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7218 {
7219         int level;
7220         level = ndr_print_get_switch_value(ndr, r);
7221         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7222         switch (level) {
7223                 case 0:
7224                         ndr_print_ptr(ndr, "info0", r->info0);
7225                         ndr->depth++;
7226                         if (r->info0) {
7227                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7228                         }
7229                         ndr->depth--;
7230                 break;
7231
7232                 case 1:
7233                         ndr_print_ptr(ndr, "info1", r->info1);
7234                         ndr->depth++;
7235                         if (r->info1) {
7236                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7237                         }
7238                         ndr->depth--;
7239                 break;
7240
7241                 case 2:
7242                         ndr_print_ptr(ndr, "info2", r->info2);
7243                         ndr->depth++;
7244                         if (r->info2) {
7245                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7246                         }
7247                         ndr->depth--;
7248                 break;
7249
7250                 case 3:
7251                         ndr_print_ptr(ndr, "info3", r->info3);
7252                         ndr->depth++;
7253                         if (r->info3) {
7254                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7255                         }
7256                         ndr->depth--;
7257                 break;
7258
7259                 case 4:
7260                         ndr_print_ptr(ndr, "info4", r->info4);
7261                         ndr->depth++;
7262                         if (r->info4) {
7263                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7264                         }
7265                         ndr->depth--;
7266                 break;
7267
7268                 case 5:
7269                         ndr_print_ptr(ndr, "info5", r->info5);
7270                         ndr->depth++;
7271                         if (r->info5) {
7272                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7273                         }
7274                         ndr->depth--;
7275                 break;
7276
7277                 case 6:
7278                         ndr_print_ptr(ndr, "info6", r->info6);
7279                         ndr->depth++;
7280                         if (r->info6) {
7281                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7282                         }
7283                         ndr->depth--;
7284                 break;
7285
7286                 case 7:
7287                         ndr_print_ptr(ndr, "info7", r->info7);
7288                         ndr->depth++;
7289                         if (r->info7) {
7290                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7291                         }
7292                         ndr->depth--;
7293                 break;
7294
7295                 case 8:
7296                         ndr_print_ptr(ndr, "info8", r->info8);
7297                         ndr->depth++;
7298                         if (r->info8) {
7299                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7300                         }
7301                         ndr->depth--;
7302                 break;
7303
7304                 case 9:
7305                         ndr_print_ptr(ndr, "info9", r->info9);
7306                         ndr->depth++;
7307                         if (r->info9) {
7308                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7309                         }
7310                         ndr->depth--;
7311                 break;
7312
7313                 default:
7314                 break;
7315
7316         }
7317 }
7318
7319 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7320 {
7321         if (ndr_flags & NDR_SCALARS) {
7322                 NDR_CHECK(ndr_push_align(ndr, 4));
7323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7324                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7325                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7326         }
7327         if (ndr_flags & NDR_BUFFERS) {
7328                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7329         }
7330         return NDR_ERR_SUCCESS;
7331 }
7332
7333 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7334 {
7335         if (ndr_flags & NDR_SCALARS) {
7336                 NDR_CHECK(ndr_pull_align(ndr, 4));
7337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7338                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7339                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7343         }
7344         return NDR_ERR_SUCCESS;
7345 }
7346
7347 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7348 {
7349         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7350         ndr->depth++;
7351         ndr_print_uint32(ndr, "level", r->level);
7352         ndr_print_set_switch_value(ndr, &r->info, r->level);
7353         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7354         ndr->depth--;
7355 }
7356
7357 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7358 {
7359         if (ndr_flags & NDR_SCALARS) {
7360                 NDR_CHECK(ndr_push_align(ndr, 4));
7361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7362                 {
7363                         uint32_t _flags_save_string_array = ndr->flags;
7364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7365                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7366                         ndr->flags = _flags_save_string_array;
7367                 }
7368         }
7369         if (ndr_flags & NDR_BUFFERS) {
7370         }
7371         return NDR_ERR_SUCCESS;
7372 }
7373
7374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7375 {
7376         if (ndr_flags & NDR_SCALARS) {
7377                 NDR_CHECK(ndr_pull_align(ndr, 4));
7378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7379                 {
7380                         uint32_t _flags_save_string_array = ndr->flags;
7381                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7382                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7383                         ndr->flags = _flags_save_string_array;
7384                 }
7385         }
7386         if (ndr_flags & NDR_BUFFERS) {
7387         }
7388         return NDR_ERR_SUCCESS;
7389 }
7390
7391 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7392 {
7393         ndr_print_struct(ndr, name, "spoolss_StringArray");
7394         ndr->depth++;
7395         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);
7396         ndr_print_string_array(ndr, "string", r->string);
7397         ndr->depth--;
7398 }
7399
7400 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7401 {
7402         if (ndr_flags & NDR_SCALARS) {
7403                 NDR_CHECK(ndr_push_align(ndr, 4));
7404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7405         }
7406         if (ndr_flags & NDR_BUFFERS) {
7407                 if (r->driver_name) {
7408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7412                 }
7413         }
7414         return NDR_ERR_SUCCESS;
7415 }
7416
7417 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7418 {
7419         uint32_t _ptr_driver_name;
7420         TALLOC_CTX *_mem_save_driver_name_0;
7421         if (ndr_flags & NDR_SCALARS) {
7422                 NDR_CHECK(ndr_pull_align(ndr, 4));
7423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7424                 if (_ptr_driver_name) {
7425                         NDR_PULL_ALLOC(ndr, r->driver_name);
7426                 } else {
7427                         r->driver_name = NULL;
7428                 }
7429         }
7430         if (ndr_flags & NDR_BUFFERS) {
7431                 if (r->driver_name) {
7432                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7433                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7434                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7435                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7436                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7437                                 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));
7438                         }
7439                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7440                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7441                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7442                 }
7443         }
7444         return NDR_ERR_SUCCESS;
7445 }
7446
7447 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7448 {
7449         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7450         ndr->depth++;
7451         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7452         ndr->depth++;
7453         if (r->driver_name) {
7454                 ndr_print_string(ndr, "driver_name", r->driver_name);
7455         }
7456         ndr->depth--;
7457         ndr->depth--;
7458 }
7459
7460 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7461 {
7462         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7463         return NDR_ERR_SUCCESS;
7464 }
7465
7466 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7467 {
7468         uint32_t v;
7469         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7470         *r = v;
7471         return NDR_ERR_SUCCESS;
7472 }
7473
7474 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7475 {
7476         const char *val = NULL;
7477
7478         switch (r) {
7479                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7480                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7481                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7482                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7483         }
7484         ndr_print_enum(ndr, name, "ENUM", val, r);
7485 }
7486
7487 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7488 {
7489         if (ndr_flags & NDR_SCALARS) {
7490                 NDR_CHECK(ndr_push_align(ndr, 4));
7491                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7494                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7497         }
7498         if (ndr_flags & NDR_BUFFERS) {
7499                 if (r->driver_name) {
7500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7503                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7504                 }
7505                 if (r->architecture) {
7506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7507                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7508                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7509                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7510                 }
7511                 if (r->driver_path) {
7512                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7515                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7516                 }
7517                 if (r->data_file) {
7518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7519                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7520                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7521                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7522                 }
7523                 if (r->config_file) {
7524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529         }
7530         return NDR_ERR_SUCCESS;
7531 }
7532
7533 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7534 {
7535         uint32_t _ptr_driver_name;
7536         TALLOC_CTX *_mem_save_driver_name_0;
7537         uint32_t _ptr_architecture;
7538         TALLOC_CTX *_mem_save_architecture_0;
7539         uint32_t _ptr_driver_path;
7540         TALLOC_CTX *_mem_save_driver_path_0;
7541         uint32_t _ptr_data_file;
7542         TALLOC_CTX *_mem_save_data_file_0;
7543         uint32_t _ptr_config_file;
7544         TALLOC_CTX *_mem_save_config_file_0;
7545         if (ndr_flags & NDR_SCALARS) {
7546                 NDR_CHECK(ndr_pull_align(ndr, 4));
7547                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7549                 if (_ptr_driver_name) {
7550                         NDR_PULL_ALLOC(ndr, r->driver_name);
7551                 } else {
7552                         r->driver_name = NULL;
7553                 }
7554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7555                 if (_ptr_architecture) {
7556                         NDR_PULL_ALLOC(ndr, r->architecture);
7557                 } else {
7558                         r->architecture = NULL;
7559                 }
7560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7561                 if (_ptr_driver_path) {
7562                         NDR_PULL_ALLOC(ndr, r->driver_path);
7563                 } else {
7564                         r->driver_path = NULL;
7565                 }
7566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7567                 if (_ptr_data_file) {
7568                         NDR_PULL_ALLOC(ndr, r->data_file);
7569                 } else {
7570                         r->data_file = NULL;
7571                 }
7572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7573                 if (_ptr_config_file) {
7574                         NDR_PULL_ALLOC(ndr, r->config_file);
7575                 } else {
7576                         r->config_file = NULL;
7577                 }
7578         }
7579         if (ndr_flags & NDR_BUFFERS) {
7580                 if (r->driver_name) {
7581                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7582                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7583                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7584                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7585                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7586                                 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));
7587                         }
7588                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7589                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7590                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7591                 }
7592                 if (r->architecture) {
7593                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7594                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7597                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7598                                 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));
7599                         }
7600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7603                 }
7604                 if (r->driver_path) {
7605                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7606                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7609                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7610                                 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));
7611                         }
7612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7615                 }
7616                 if (r->data_file) {
7617                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7618                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7621                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7622                                 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));
7623                         }
7624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7627                 }
7628                 if (r->config_file) {
7629                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7630                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7633                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7634                                 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));
7635                         }
7636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7639                 }
7640         }
7641         return NDR_ERR_SUCCESS;
7642 }
7643
7644 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7645 {
7646         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7647         ndr->depth++;
7648         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7649         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7650         ndr->depth++;
7651         if (r->driver_name) {
7652                 ndr_print_string(ndr, "driver_name", r->driver_name);
7653         }
7654         ndr->depth--;
7655         ndr_print_ptr(ndr, "architecture", r->architecture);
7656         ndr->depth++;
7657         if (r->architecture) {
7658                 ndr_print_string(ndr, "architecture", r->architecture);
7659         }
7660         ndr->depth--;
7661         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7662         ndr->depth++;
7663         if (r->driver_path) {
7664                 ndr_print_string(ndr, "driver_path", r->driver_path);
7665         }
7666         ndr->depth--;
7667         ndr_print_ptr(ndr, "data_file", r->data_file);
7668         ndr->depth++;
7669         if (r->data_file) {
7670                 ndr_print_string(ndr, "data_file", r->data_file);
7671         }
7672         ndr->depth--;
7673         ndr_print_ptr(ndr, "config_file", r->config_file);
7674         ndr->depth++;
7675         if (r->config_file) {
7676                 ndr_print_string(ndr, "config_file", r->config_file);
7677         }
7678         ndr->depth--;
7679         ndr->depth--;
7680 }
7681
7682 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7683 {
7684         if (ndr_flags & NDR_SCALARS) {
7685                 NDR_CHECK(ndr_push_align(ndr, 4));
7686                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7697         }
7698         if (ndr_flags & NDR_BUFFERS) {
7699                 if (r->driver_name) {
7700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7704                 }
7705                 if (r->architecture) {
7706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7710                 }
7711                 if (r->driver_path) {
7712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7715                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7716                 }
7717                 if (r->data_file) {
7718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7721                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7722                 }
7723                 if (r->config_file) {
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7728                 }
7729                 if (r->help_file) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 if (r->monitor_name) {
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7740                 }
7741                 if (r->default_datatype) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 if (r->dependent_files) {
7748                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7749                 }
7750         }
7751         return NDR_ERR_SUCCESS;
7752 }
7753
7754 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7755 {
7756         uint32_t _ptr_driver_name;
7757         TALLOC_CTX *_mem_save_driver_name_0;
7758         uint32_t _ptr_architecture;
7759         TALLOC_CTX *_mem_save_architecture_0;
7760         uint32_t _ptr_driver_path;
7761         TALLOC_CTX *_mem_save_driver_path_0;
7762         uint32_t _ptr_data_file;
7763         TALLOC_CTX *_mem_save_data_file_0;
7764         uint32_t _ptr_config_file;
7765         TALLOC_CTX *_mem_save_config_file_0;
7766         uint32_t _ptr_help_file;
7767         TALLOC_CTX *_mem_save_help_file_0;
7768         uint32_t _ptr_monitor_name;
7769         TALLOC_CTX *_mem_save_monitor_name_0;
7770         uint32_t _ptr_default_datatype;
7771         TALLOC_CTX *_mem_save_default_datatype_0;
7772         uint32_t _ptr_dependent_files;
7773         TALLOC_CTX *_mem_save_dependent_files_0;
7774         if (ndr_flags & NDR_SCALARS) {
7775                 NDR_CHECK(ndr_pull_align(ndr, 4));
7776                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7778                 if (_ptr_driver_name) {
7779                         NDR_PULL_ALLOC(ndr, r->driver_name);
7780                 } else {
7781                         r->driver_name = NULL;
7782                 }
7783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7784                 if (_ptr_architecture) {
7785                         NDR_PULL_ALLOC(ndr, r->architecture);
7786                 } else {
7787                         r->architecture = NULL;
7788                 }
7789                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7790                 if (_ptr_driver_path) {
7791                         NDR_PULL_ALLOC(ndr, r->driver_path);
7792                 } else {
7793                         r->driver_path = NULL;
7794                 }
7795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7796                 if (_ptr_data_file) {
7797                         NDR_PULL_ALLOC(ndr, r->data_file);
7798                 } else {
7799                         r->data_file = NULL;
7800                 }
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7802                 if (_ptr_config_file) {
7803                         NDR_PULL_ALLOC(ndr, r->config_file);
7804                 } else {
7805                         r->config_file = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7808                 if (_ptr_help_file) {
7809                         NDR_PULL_ALLOC(ndr, r->help_file);
7810                 } else {
7811                         r->help_file = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7814                 if (_ptr_monitor_name) {
7815                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7816                 } else {
7817                         r->monitor_name = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7820                 if (_ptr_default_datatype) {
7821                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7822                 } else {
7823                         r->default_datatype = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7827                 if (_ptr_dependent_files) {
7828                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7829                 } else {
7830                         r->dependent_files = NULL;
7831                 }
7832         }
7833         if (ndr_flags & NDR_BUFFERS) {
7834                 if (r->driver_name) {
7835                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7836                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7837                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7838                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7839                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7840                                 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));
7841                         }
7842                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7843                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7845                 }
7846                 if (r->architecture) {
7847                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7848                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7849                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7850                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7851                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7852                                 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));
7853                         }
7854                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7855                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7857                 }
7858                 if (r->driver_path) {
7859                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7863                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7864                                 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));
7865                         }
7866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7869                 }
7870                 if (r->data_file) {
7871                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7872                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7875                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7876                                 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));
7877                         }
7878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7881                 }
7882                 if (r->config_file) {
7883                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7887                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7888                                 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));
7889                         }
7890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7893                 }
7894                 if (r->help_file) {
7895                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7896                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7899                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7900                                 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));
7901                         }
7902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7905                 }
7906                 if (r->monitor_name) {
7907                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7911                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7912                                 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));
7913                         }
7914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7917                 }
7918                 if (r->default_datatype) {
7919                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7923                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7924                                 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));
7925                         }
7926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7929                 }
7930                 if (r->dependent_files) {
7931                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7933                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7935                 }
7936         }
7937         return NDR_ERR_SUCCESS;
7938 }
7939
7940 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7941 {
7942         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7943         ndr->depth++;
7944         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7945         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7946         ndr->depth++;
7947         if (r->driver_name) {
7948                 ndr_print_string(ndr, "driver_name", r->driver_name);
7949         }
7950         ndr->depth--;
7951         ndr_print_ptr(ndr, "architecture", r->architecture);
7952         ndr->depth++;
7953         if (r->architecture) {
7954                 ndr_print_string(ndr, "architecture", r->architecture);
7955         }
7956         ndr->depth--;
7957         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7958         ndr->depth++;
7959         if (r->driver_path) {
7960                 ndr_print_string(ndr, "driver_path", r->driver_path);
7961         }
7962         ndr->depth--;
7963         ndr_print_ptr(ndr, "data_file", r->data_file);
7964         ndr->depth++;
7965         if (r->data_file) {
7966                 ndr_print_string(ndr, "data_file", r->data_file);
7967         }
7968         ndr->depth--;
7969         ndr_print_ptr(ndr, "config_file", r->config_file);
7970         ndr->depth++;
7971         if (r->config_file) {
7972                 ndr_print_string(ndr, "config_file", r->config_file);
7973         }
7974         ndr->depth--;
7975         ndr_print_ptr(ndr, "help_file", r->help_file);
7976         ndr->depth++;
7977         if (r->help_file) {
7978                 ndr_print_string(ndr, "help_file", r->help_file);
7979         }
7980         ndr->depth--;
7981         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7982         ndr->depth++;
7983         if (r->monitor_name) {
7984                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7985         }
7986         ndr->depth--;
7987         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7988         ndr->depth++;
7989         if (r->default_datatype) {
7990                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7991         }
7992         ndr->depth--;
7993         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);
7994         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7995         ndr->depth++;
7996         if (r->dependent_files) {
7997                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7998         }
7999         ndr->depth--;
8000         ndr->depth--;
8001 }
8002
8003 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8004 {
8005         if (ndr_flags & NDR_SCALARS) {
8006                 NDR_CHECK(ndr_push_align(ndr, 4));
8007                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8009                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8020         }
8021         if (ndr_flags & NDR_BUFFERS) {
8022                 if (r->driver_name) {
8023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8027                 }
8028                 if (r->architecture) {
8029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8033                 }
8034                 if (r->driver_path) {
8035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8038                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8039                 }
8040                 if (r->data_file) {
8041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8044                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8045                 }
8046                 if (r->config_file) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->help_file) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->monitor_name) {
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8063                 }
8064                 if (r->default_datatype) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 if (r->dependent_files) {
8071                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8072                 }
8073                 if (r->previous_names) {
8074                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8075                 }
8076         }
8077         return NDR_ERR_SUCCESS;
8078 }
8079
8080 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8081 {
8082         uint32_t _ptr_driver_name;
8083         TALLOC_CTX *_mem_save_driver_name_0;
8084         uint32_t _ptr_architecture;
8085         TALLOC_CTX *_mem_save_architecture_0;
8086         uint32_t _ptr_driver_path;
8087         TALLOC_CTX *_mem_save_driver_path_0;
8088         uint32_t _ptr_data_file;
8089         TALLOC_CTX *_mem_save_data_file_0;
8090         uint32_t _ptr_config_file;
8091         TALLOC_CTX *_mem_save_config_file_0;
8092         uint32_t _ptr_help_file;
8093         TALLOC_CTX *_mem_save_help_file_0;
8094         uint32_t _ptr_monitor_name;
8095         TALLOC_CTX *_mem_save_monitor_name_0;
8096         uint32_t _ptr_default_datatype;
8097         TALLOC_CTX *_mem_save_default_datatype_0;
8098         uint32_t _ptr_dependent_files;
8099         TALLOC_CTX *_mem_save_dependent_files_0;
8100         uint32_t _ptr_previous_names;
8101         TALLOC_CTX *_mem_save_previous_names_0;
8102         if (ndr_flags & NDR_SCALARS) {
8103                 NDR_CHECK(ndr_pull_align(ndr, 4));
8104                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8106                 if (_ptr_driver_name) {
8107                         NDR_PULL_ALLOC(ndr, r->driver_name);
8108                 } else {
8109                         r->driver_name = NULL;
8110                 }
8111                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8112                 if (_ptr_architecture) {
8113                         NDR_PULL_ALLOC(ndr, r->architecture);
8114                 } else {
8115                         r->architecture = NULL;
8116                 }
8117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8118                 if (_ptr_driver_path) {
8119                         NDR_PULL_ALLOC(ndr, r->driver_path);
8120                 } else {
8121                         r->driver_path = NULL;
8122                 }
8123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8124                 if (_ptr_data_file) {
8125                         NDR_PULL_ALLOC(ndr, r->data_file);
8126                 } else {
8127                         r->data_file = NULL;
8128                 }
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8130                 if (_ptr_config_file) {
8131                         NDR_PULL_ALLOC(ndr, r->config_file);
8132                 } else {
8133                         r->config_file = NULL;
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8136                 if (_ptr_help_file) {
8137                         NDR_PULL_ALLOC(ndr, r->help_file);
8138                 } else {
8139                         r->help_file = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8142                 if (_ptr_monitor_name) {
8143                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8144                 } else {
8145                         r->monitor_name = NULL;
8146                 }
8147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8148                 if (_ptr_default_datatype) {
8149                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8150                 } else {
8151                         r->default_datatype = NULL;
8152                 }
8153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8155                 if (_ptr_dependent_files) {
8156                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8157                 } else {
8158                         r->dependent_files = NULL;
8159                 }
8160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8162                 if (_ptr_previous_names) {
8163                         NDR_PULL_ALLOC(ndr, r->previous_names);
8164                 } else {
8165                         r->previous_names = NULL;
8166                 }
8167         }
8168         if (ndr_flags & NDR_BUFFERS) {
8169                 if (r->driver_name) {
8170                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8171                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8174                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8175                                 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));
8176                         }
8177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8180                 }
8181                 if (r->architecture) {
8182                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8183                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8186                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8187                                 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));
8188                         }
8189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8192                 }
8193                 if (r->driver_path) {
8194                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8198                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8199                                 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));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8204                 }
8205                 if (r->data_file) {
8206                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8210                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8211                                 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));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8216                 }
8217                 if (r->config_file) {
8218                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8222                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8223                                 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));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8228                 }
8229                 if (r->help_file) {
8230                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8234                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8235                                 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));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8240                 }
8241                 if (r->monitor_name) {
8242                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8246                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8247                                 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));
8248                         }
8249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8252                 }
8253                 if (r->default_datatype) {
8254                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8258                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8259                                 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));
8260                         }
8261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8264                 }
8265                 if (r->dependent_files) {
8266                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8267                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8268                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8270                 }
8271                 if (r->previous_names) {
8272                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8273                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8274                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8276                 }
8277         }
8278         return NDR_ERR_SUCCESS;
8279 }
8280
8281 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8282 {
8283         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8284         ndr->depth++;
8285         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8286         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8287         ndr->depth++;
8288         if (r->driver_name) {
8289                 ndr_print_string(ndr, "driver_name", r->driver_name);
8290         }
8291         ndr->depth--;
8292         ndr_print_ptr(ndr, "architecture", r->architecture);
8293         ndr->depth++;
8294         if (r->architecture) {
8295                 ndr_print_string(ndr, "architecture", r->architecture);
8296         }
8297         ndr->depth--;
8298         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8299         ndr->depth++;
8300         if (r->driver_path) {
8301                 ndr_print_string(ndr, "driver_path", r->driver_path);
8302         }
8303         ndr->depth--;
8304         ndr_print_ptr(ndr, "data_file", r->data_file);
8305         ndr->depth++;
8306         if (r->data_file) {
8307                 ndr_print_string(ndr, "data_file", r->data_file);
8308         }
8309         ndr->depth--;
8310         ndr_print_ptr(ndr, "config_file", r->config_file);
8311         ndr->depth++;
8312         if (r->config_file) {
8313                 ndr_print_string(ndr, "config_file", r->config_file);
8314         }
8315         ndr->depth--;
8316         ndr_print_ptr(ndr, "help_file", r->help_file);
8317         ndr->depth++;
8318         if (r->help_file) {
8319                 ndr_print_string(ndr, "help_file", r->help_file);
8320         }
8321         ndr->depth--;
8322         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8323         ndr->depth++;
8324         if (r->monitor_name) {
8325                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8326         }
8327         ndr->depth--;
8328         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8329         ndr->depth++;
8330         if (r->default_datatype) {
8331                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8332         }
8333         ndr->depth--;
8334         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);
8335         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8336         ndr->depth++;
8337         if (r->dependent_files) {
8338                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8339         }
8340         ndr->depth--;
8341         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);
8342         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8343         ndr->depth++;
8344         if (r->previous_names) {
8345                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8346         }
8347         ndr->depth--;
8348         ndr->depth--;
8349 }
8350
8351 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8352 {
8353         if (ndr_flags & NDR_SCALARS) {
8354                 NDR_CHECK(ndr_push_align(ndr, 8));
8355                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8368                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8369                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8374         }
8375         if (ndr_flags & NDR_BUFFERS) {
8376                 if (r->driver_name) {
8377                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8378                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8381                 }
8382                 if (r->architecture) {
8383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8387                 }
8388                 if (r->driver_path) {
8389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8393                 }
8394                 if (r->data_file) {
8395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8399                 }
8400                 if (r->config_file) {
8401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8405                 }
8406                 if (r->help_file) {
8407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8411                 }
8412                 if (r->monitor_name) {
8413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8417                 }
8418                 if (r->default_datatype) {
8419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8423                 }
8424                 if (r->dependent_files) {
8425                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8426                 }
8427                 if (r->previous_names) {
8428                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8429                 }
8430                 if (r->manufacturer_name) {
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8435                 }
8436                 if (r->manufacturer_url) {
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8441                 }
8442                 if (r->hardware_id) {
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8447                 }
8448                 if (r->provider) {
8449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8452                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8453                 }
8454         }
8455         return NDR_ERR_SUCCESS;
8456 }
8457
8458 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8459 {
8460         uint32_t _ptr_driver_name;
8461         TALLOC_CTX *_mem_save_driver_name_0;
8462         uint32_t _ptr_architecture;
8463         TALLOC_CTX *_mem_save_architecture_0;
8464         uint32_t _ptr_driver_path;
8465         TALLOC_CTX *_mem_save_driver_path_0;
8466         uint32_t _ptr_data_file;
8467         TALLOC_CTX *_mem_save_data_file_0;
8468         uint32_t _ptr_config_file;
8469         TALLOC_CTX *_mem_save_config_file_0;
8470         uint32_t _ptr_help_file;
8471         TALLOC_CTX *_mem_save_help_file_0;
8472         uint32_t _ptr_monitor_name;
8473         TALLOC_CTX *_mem_save_monitor_name_0;
8474         uint32_t _ptr_default_datatype;
8475         TALLOC_CTX *_mem_save_default_datatype_0;
8476         uint32_t _ptr_dependent_files;
8477         TALLOC_CTX *_mem_save_dependent_files_0;
8478         uint32_t _ptr_previous_names;
8479         TALLOC_CTX *_mem_save_previous_names_0;
8480         uint32_t _ptr_manufacturer_name;
8481         TALLOC_CTX *_mem_save_manufacturer_name_0;
8482         uint32_t _ptr_manufacturer_url;
8483         TALLOC_CTX *_mem_save_manufacturer_url_0;
8484         uint32_t _ptr_hardware_id;
8485         TALLOC_CTX *_mem_save_hardware_id_0;
8486         uint32_t _ptr_provider;
8487         TALLOC_CTX *_mem_save_provider_0;
8488         if (ndr_flags & NDR_SCALARS) {
8489                 NDR_CHECK(ndr_pull_align(ndr, 8));
8490                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8492                 if (_ptr_driver_name) {
8493                         NDR_PULL_ALLOC(ndr, r->driver_name);
8494                 } else {
8495                         r->driver_name = NULL;
8496                 }
8497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8498                 if (_ptr_architecture) {
8499                         NDR_PULL_ALLOC(ndr, r->architecture);
8500                 } else {
8501                         r->architecture = NULL;
8502                 }
8503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8504                 if (_ptr_driver_path) {
8505                         NDR_PULL_ALLOC(ndr, r->driver_path);
8506                 } else {
8507                         r->driver_path = NULL;
8508                 }
8509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8510                 if (_ptr_data_file) {
8511                         NDR_PULL_ALLOC(ndr, r->data_file);
8512                 } else {
8513                         r->data_file = NULL;
8514                 }
8515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8516                 if (_ptr_config_file) {
8517                         NDR_PULL_ALLOC(ndr, r->config_file);
8518                 } else {
8519                         r->config_file = NULL;
8520                 }
8521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8522                 if (_ptr_help_file) {
8523                         NDR_PULL_ALLOC(ndr, r->help_file);
8524                 } else {
8525                         r->help_file = NULL;
8526                 }
8527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8528                 if (_ptr_monitor_name) {
8529                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8530                 } else {
8531                         r->monitor_name = NULL;
8532                 }
8533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8534                 if (_ptr_default_datatype) {
8535                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8536                 } else {
8537                         r->default_datatype = NULL;
8538                 }
8539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8541                 if (_ptr_dependent_files) {
8542                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8543                 } else {
8544                         r->dependent_files = NULL;
8545                 }
8546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8548                 if (_ptr_previous_names) {
8549                         NDR_PULL_ALLOC(ndr, r->previous_names);
8550                 } else {
8551                         r->previous_names = NULL;
8552                 }
8553                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8554                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8556                 if (_ptr_manufacturer_name) {
8557                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8558                 } else {
8559                         r->manufacturer_name = NULL;
8560                 }
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8562                 if (_ptr_manufacturer_url) {
8563                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8564                 } else {
8565                         r->manufacturer_url = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8568                 if (_ptr_hardware_id) {
8569                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8570                 } else {
8571                         r->hardware_id = NULL;
8572                 }
8573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8574                 if (_ptr_provider) {
8575                         NDR_PULL_ALLOC(ndr, r->provider);
8576                 } else {
8577                         r->provider = NULL;
8578                 }
8579         }
8580         if (ndr_flags & NDR_BUFFERS) {
8581                 if (r->driver_name) {
8582                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8583                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8586                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8587                                 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));
8588                         }
8589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8592                 }
8593                 if (r->architecture) {
8594                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8595                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8598                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8599                                 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));
8600                         }
8601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8604                 }
8605                 if (r->driver_path) {
8606                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8607                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8610                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8611                                 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));
8612                         }
8613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8616                 }
8617                 if (r->data_file) {
8618                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8619                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8622                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8623                                 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));
8624                         }
8625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8628                 }
8629                 if (r->config_file) {
8630                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8631                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8634                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8635                                 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));
8636                         }
8637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8640                 }
8641                 if (r->help_file) {
8642                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8646                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8647                                 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));
8648                         }
8649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8652                 }
8653                 if (r->monitor_name) {
8654                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8655                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8658                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8659                                 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));
8660                         }
8661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8664                 }
8665                 if (r->default_datatype) {
8666                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8667                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8670                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8671                                 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));
8672                         }
8673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8676                 }
8677                 if (r->dependent_files) {
8678                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8679                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8680                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8681                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8682                 }
8683                 if (r->previous_names) {
8684                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8685                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8686                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8688                 }
8689                 if (r->manufacturer_name) {
8690                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8694                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8695                                 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));
8696                         }
8697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8700                 }
8701                 if (r->manufacturer_url) {
8702                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8703                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8704                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8705                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8706                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8707                                 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));
8708                         }
8709                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8710                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8712                 }
8713                 if (r->hardware_id) {
8714                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8718                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8719                                 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));
8720                         }
8721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8724                 }
8725                 if (r->provider) {
8726                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8727                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8730                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8731                                 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));
8732                         }
8733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8736                 }
8737         }
8738         return NDR_ERR_SUCCESS;
8739 }
8740
8741 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8742 {
8743         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8744         ndr->depth++;
8745         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8746         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8747         ndr->depth++;
8748         if (r->driver_name) {
8749                 ndr_print_string(ndr, "driver_name", r->driver_name);
8750         }
8751         ndr->depth--;
8752         ndr_print_ptr(ndr, "architecture", r->architecture);
8753         ndr->depth++;
8754         if (r->architecture) {
8755                 ndr_print_string(ndr, "architecture", r->architecture);
8756         }
8757         ndr->depth--;
8758         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8759         ndr->depth++;
8760         if (r->driver_path) {
8761                 ndr_print_string(ndr, "driver_path", r->driver_path);
8762         }
8763         ndr->depth--;
8764         ndr_print_ptr(ndr, "data_file", r->data_file);
8765         ndr->depth++;
8766         if (r->data_file) {
8767                 ndr_print_string(ndr, "data_file", r->data_file);
8768         }
8769         ndr->depth--;
8770         ndr_print_ptr(ndr, "config_file", r->config_file);
8771         ndr->depth++;
8772         if (r->config_file) {
8773                 ndr_print_string(ndr, "config_file", r->config_file);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "help_file", r->help_file);
8777         ndr->depth++;
8778         if (r->help_file) {
8779                 ndr_print_string(ndr, "help_file", r->help_file);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8783         ndr->depth++;
8784         if (r->monitor_name) {
8785                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8789         ndr->depth++;
8790         if (r->default_datatype) {
8791                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8792         }
8793         ndr->depth--;
8794         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);
8795         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8796         ndr->depth++;
8797         if (r->dependent_files) {
8798                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8799         }
8800         ndr->depth--;
8801         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);
8802         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8803         ndr->depth++;
8804         if (r->previous_names) {
8805                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8806         }
8807         ndr->depth--;
8808         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8809         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8810         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8811         ndr->depth++;
8812         if (r->manufacturer_name) {
8813                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8814         }
8815         ndr->depth--;
8816         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8817         ndr->depth++;
8818         if (r->manufacturer_url) {
8819                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8820         }
8821         ndr->depth--;
8822         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8823         ndr->depth++;
8824         if (r->hardware_id) {
8825                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8826         }
8827         ndr->depth--;
8828         ndr_print_ptr(ndr, "provider", r->provider);
8829         ndr->depth++;
8830         if (r->provider) {
8831                 ndr_print_string(ndr, "provider", r->provider);
8832         }
8833         ndr->depth--;
8834         ndr->depth--;
8835 }
8836
8837 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8838 {
8839         if (ndr_flags & NDR_SCALARS) {
8840                 NDR_CHECK(ndr_push_align(ndr, 8));
8841                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8844                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8845                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8846                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8850                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8854                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8855                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8858                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8859                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8860                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8868                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8869                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8870         }
8871         if (ndr_flags & NDR_BUFFERS) {
8872                 if (r->driver_name) {
8873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8875                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8876                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8877                 }
8878                 if (r->architecture) {
8879                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8881                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8882                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8883                 }
8884                 if (r->driver_path) {
8885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8886                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8888                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8889                 }
8890                 if (r->data_file) {
8891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8894                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8895                 }
8896                 if (r->config_file) {
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8901                 }
8902                 if (r->help_file) {
8903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8907                 }
8908                 if (r->monitor_name) {
8909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8913                 }
8914                 if (r->default_datatype) {
8915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8919                 }
8920                 if (r->dependent_files) {
8921                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8922                 }
8923                 if (r->previous_names) {
8924                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8925                 }
8926                 if (r->manufacturer_name) {
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8931                 }
8932                 if (r->manufacturer_url) {
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8937                 }
8938                 if (r->hardware_id) {
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8943                 }
8944                 if (r->provider) {
8945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8948                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8949                 }
8950                 if (r->print_processor) {
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8955                 }
8956                 if (r->vendor_setup) {
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8960                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8961                 }
8962                 if (r->color_profiles) {
8963                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8964                 }
8965                 if (r->inf_path) {
8966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8968                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8970                 }
8971                 if (r->core_driver_dependencies) {
8972                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8973                 }
8974         }
8975         return NDR_ERR_SUCCESS;
8976 }
8977
8978 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8979 {
8980         uint32_t _ptr_driver_name;
8981         TALLOC_CTX *_mem_save_driver_name_0;
8982         uint32_t _ptr_architecture;
8983         TALLOC_CTX *_mem_save_architecture_0;
8984         uint32_t _ptr_driver_path;
8985         TALLOC_CTX *_mem_save_driver_path_0;
8986         uint32_t _ptr_data_file;
8987         TALLOC_CTX *_mem_save_data_file_0;
8988         uint32_t _ptr_config_file;
8989         TALLOC_CTX *_mem_save_config_file_0;
8990         uint32_t _ptr_help_file;
8991         TALLOC_CTX *_mem_save_help_file_0;
8992         uint32_t _ptr_monitor_name;
8993         TALLOC_CTX *_mem_save_monitor_name_0;
8994         uint32_t _ptr_default_datatype;
8995         TALLOC_CTX *_mem_save_default_datatype_0;
8996         uint32_t _ptr_dependent_files;
8997         TALLOC_CTX *_mem_save_dependent_files_0;
8998         uint32_t _ptr_previous_names;
8999         TALLOC_CTX *_mem_save_previous_names_0;
9000         uint32_t _ptr_manufacturer_name;
9001         TALLOC_CTX *_mem_save_manufacturer_name_0;
9002         uint32_t _ptr_manufacturer_url;
9003         TALLOC_CTX *_mem_save_manufacturer_url_0;
9004         uint32_t _ptr_hardware_id;
9005         TALLOC_CTX *_mem_save_hardware_id_0;
9006         uint32_t _ptr_provider;
9007         TALLOC_CTX *_mem_save_provider_0;
9008         uint32_t _ptr_print_processor;
9009         TALLOC_CTX *_mem_save_print_processor_0;
9010         uint32_t _ptr_vendor_setup;
9011         TALLOC_CTX *_mem_save_vendor_setup_0;
9012         uint32_t _ptr_color_profiles;
9013         TALLOC_CTX *_mem_save_color_profiles_0;
9014         uint32_t _ptr_inf_path;
9015         TALLOC_CTX *_mem_save_inf_path_0;
9016         uint32_t _ptr_core_driver_dependencies;
9017         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_pull_align(ndr, 8));
9020                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9021                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9022                 if (_ptr_driver_name) {
9023                         NDR_PULL_ALLOC(ndr, r->driver_name);
9024                 } else {
9025                         r->driver_name = NULL;
9026                 }
9027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9028                 if (_ptr_architecture) {
9029                         NDR_PULL_ALLOC(ndr, r->architecture);
9030                 } else {
9031                         r->architecture = NULL;
9032                 }
9033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9034                 if (_ptr_driver_path) {
9035                         NDR_PULL_ALLOC(ndr, r->driver_path);
9036                 } else {
9037                         r->driver_path = NULL;
9038                 }
9039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9040                 if (_ptr_data_file) {
9041                         NDR_PULL_ALLOC(ndr, r->data_file);
9042                 } else {
9043                         r->data_file = NULL;
9044                 }
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9046                 if (_ptr_config_file) {
9047                         NDR_PULL_ALLOC(ndr, r->config_file);
9048                 } else {
9049                         r->config_file = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9052                 if (_ptr_help_file) {
9053                         NDR_PULL_ALLOC(ndr, r->help_file);
9054                 } else {
9055                         r->help_file = NULL;
9056                 }
9057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9058                 if (_ptr_monitor_name) {
9059                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9060                 } else {
9061                         r->monitor_name = NULL;
9062                 }
9063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9064                 if (_ptr_default_datatype) {
9065                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9066                 } else {
9067                         r->default_datatype = NULL;
9068                 }
9069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9071                 if (_ptr_dependent_files) {
9072                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9073                 } else {
9074                         r->dependent_files = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9078                 if (_ptr_previous_names) {
9079                         NDR_PULL_ALLOC(ndr, r->previous_names);
9080                 } else {
9081                         r->previous_names = NULL;
9082                 }
9083                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9084                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9086                 if (_ptr_manufacturer_name) {
9087                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9088                 } else {
9089                         r->manufacturer_name = NULL;
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9092                 if (_ptr_manufacturer_url) {
9093                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9094                 } else {
9095                         r->manufacturer_url = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9098                 if (_ptr_hardware_id) {
9099                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9100                 } else {
9101                         r->hardware_id = NULL;
9102                 }
9103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9104                 if (_ptr_provider) {
9105                         NDR_PULL_ALLOC(ndr, r->provider);
9106                 } else {
9107                         r->provider = NULL;
9108                 }
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9110                 if (_ptr_print_processor) {
9111                         NDR_PULL_ALLOC(ndr, r->print_processor);
9112                 } else {
9113                         r->print_processor = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9116                 if (_ptr_vendor_setup) {
9117                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9118                 } else {
9119                         r->vendor_setup = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9123                 if (_ptr_color_profiles) {
9124                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9125                 } else {
9126                         r->color_profiles = NULL;
9127                 }
9128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9129                 if (_ptr_inf_path) {
9130                         NDR_PULL_ALLOC(ndr, r->inf_path);
9131                 } else {
9132                         r->inf_path = NULL;
9133                 }
9134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9137                 if (_ptr_core_driver_dependencies) {
9138                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9139                 } else {
9140                         r->core_driver_dependencies = NULL;
9141                 }
9142                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9143                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9144         }
9145         if (ndr_flags & NDR_BUFFERS) {
9146                 if (r->driver_name) {
9147                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9148                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9149                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9150                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9151                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9152                                 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));
9153                         }
9154                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9155                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9157                 }
9158                 if (r->architecture) {
9159                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9160                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9163                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9164                                 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));
9165                         }
9166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9167                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9169                 }
9170                 if (r->driver_path) {
9171                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9172                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9175                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9176                                 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));
9177                         }
9178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9181                 }
9182                 if (r->data_file) {
9183                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9184                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9187                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9188                                 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));
9189                         }
9190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9193                 }
9194                 if (r->config_file) {
9195                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9196                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9199                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9200                                 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));
9201                         }
9202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9205                 }
9206                 if (r->help_file) {
9207                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9211                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9212                                 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));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9217                 }
9218                 if (r->monitor_name) {
9219                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9220                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9223                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9224                                 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));
9225                         }
9226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9229                 }
9230                 if (r->default_datatype) {
9231                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9235                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9236                                 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));
9237                         }
9238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9241                 }
9242                 if (r->dependent_files) {
9243                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9245                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9247                 }
9248                 if (r->previous_names) {
9249                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9250                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9251                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9253                 }
9254                 if (r->manufacturer_name) {
9255                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9256                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9259                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9260                                 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));
9261                         }
9262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9265                 }
9266                 if (r->manufacturer_url) {
9267                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9271                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9272                                 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));
9273                         }
9274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9277                 }
9278                 if (r->hardware_id) {
9279                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9283                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9284                                 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));
9285                         }
9286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9289                 }
9290                 if (r->provider) {
9291                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9295                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9296                                 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));
9297                         }
9298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9301                 }
9302                 if (r->print_processor) {
9303                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9304                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9307                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9308                                 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));
9309                         }
9310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9313                 }
9314                 if (r->vendor_setup) {
9315                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9316                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9319                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9320                                 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));
9321                         }
9322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9325                 }
9326                 if (r->color_profiles) {
9327                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9328                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9329                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9331                 }
9332                 if (r->inf_path) {
9333                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9334                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9336                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9337                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9338                                 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));
9339                         }
9340                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9341                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9342                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9343                 }
9344                 if (r->core_driver_dependencies) {
9345                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9346                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9347                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9349                 }
9350         }
9351         return NDR_ERR_SUCCESS;
9352 }
9353
9354 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9355 {
9356         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9357         ndr->depth++;
9358         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9359         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9360         ndr->depth++;
9361         if (r->driver_name) {
9362                 ndr_print_string(ndr, "driver_name", r->driver_name);
9363         }
9364         ndr->depth--;
9365         ndr_print_ptr(ndr, "architecture", r->architecture);
9366         ndr->depth++;
9367         if (r->architecture) {
9368                 ndr_print_string(ndr, "architecture", r->architecture);
9369         }
9370         ndr->depth--;
9371         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9372         ndr->depth++;
9373         if (r->driver_path) {
9374                 ndr_print_string(ndr, "driver_path", r->driver_path);
9375         }
9376         ndr->depth--;
9377         ndr_print_ptr(ndr, "data_file", r->data_file);
9378         ndr->depth++;
9379         if (r->data_file) {
9380                 ndr_print_string(ndr, "data_file", r->data_file);
9381         }
9382         ndr->depth--;
9383         ndr_print_ptr(ndr, "config_file", r->config_file);
9384         ndr->depth++;
9385         if (r->config_file) {
9386                 ndr_print_string(ndr, "config_file", r->config_file);
9387         }
9388         ndr->depth--;
9389         ndr_print_ptr(ndr, "help_file", r->help_file);
9390         ndr->depth++;
9391         if (r->help_file) {
9392                 ndr_print_string(ndr, "help_file", r->help_file);
9393         }
9394         ndr->depth--;
9395         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9396         ndr->depth++;
9397         if (r->monitor_name) {
9398                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9399         }
9400         ndr->depth--;
9401         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9402         ndr->depth++;
9403         if (r->default_datatype) {
9404                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9405         }
9406         ndr->depth--;
9407         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);
9408         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9409         ndr->depth++;
9410         if (r->dependent_files) {
9411                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9412         }
9413         ndr->depth--;
9414         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);
9415         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9416         ndr->depth++;
9417         if (r->previous_names) {
9418                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9419         }
9420         ndr->depth--;
9421         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9422         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9423         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9424         ndr->depth++;
9425         if (r->manufacturer_name) {
9426                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9427         }
9428         ndr->depth--;
9429         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9430         ndr->depth++;
9431         if (r->manufacturer_url) {
9432                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9433         }
9434         ndr->depth--;
9435         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9436         ndr->depth++;
9437         if (r->hardware_id) {
9438                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9439         }
9440         ndr->depth--;
9441         ndr_print_ptr(ndr, "provider", r->provider);
9442         ndr->depth++;
9443         if (r->provider) {
9444                 ndr_print_string(ndr, "provider", r->provider);
9445         }
9446         ndr->depth--;
9447         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9448         ndr->depth++;
9449         if (r->print_processor) {
9450                 ndr_print_string(ndr, "print_processor", r->print_processor);
9451         }
9452         ndr->depth--;
9453         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9454         ndr->depth++;
9455         if (r->vendor_setup) {
9456                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9457         }
9458         ndr->depth--;
9459         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);
9460         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9461         ndr->depth++;
9462         if (r->color_profiles) {
9463                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9464         }
9465         ndr->depth--;
9466         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9467         ndr->depth++;
9468         if (r->inf_path) {
9469                 ndr_print_string(ndr, "inf_path", r->inf_path);
9470         }
9471         ndr->depth--;
9472         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9473         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);
9474         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9475         ndr->depth++;
9476         if (r->core_driver_dependencies) {
9477                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9478         }
9479         ndr->depth--;
9480         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9481         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9482         ndr->depth--;
9483 }
9484
9485 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9486 {
9487         if (ndr_flags & NDR_SCALARS) {
9488                 int level = ndr_push_get_switch_value(ndr, r);
9489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9490                 switch (level) {
9491                         case 1: {
9492                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9493                         break; }
9494
9495                         case 2: {
9496                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9497                         break; }
9498
9499                         case 3: {
9500                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9501                         break; }
9502
9503                         case 4: {
9504                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9505                         break; }
9506
9507                         case 6: {
9508                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9509                         break; }
9510
9511                         case 8: {
9512                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9513                         break; }
9514
9515                         default:
9516                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9517                 }
9518         }
9519         if (ndr_flags & NDR_BUFFERS) {
9520                 int level = ndr_push_get_switch_value(ndr, r);
9521                 switch (level) {
9522                         case 1:
9523                                 if (r->info1) {
9524                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9525                                 }
9526                         break;
9527
9528                         case 2:
9529                                 if (r->info2) {
9530                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9531                                 }
9532                         break;
9533
9534                         case 3:
9535                                 if (r->info3) {
9536                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9537                                 }
9538                         break;
9539
9540                         case 4:
9541                                 if (r->info4) {
9542                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9543                                 }
9544                         break;
9545
9546                         case 6:
9547                                 if (r->info6) {
9548                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9549                                 }
9550                         break;
9551
9552                         case 8:
9553                                 if (r->info8) {
9554                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9555                                 }
9556                         break;
9557
9558                         default:
9559                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9560                 }
9561         }
9562         return NDR_ERR_SUCCESS;
9563 }
9564
9565 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9566 {
9567         int level;
9568         uint32_t _level;
9569         TALLOC_CTX *_mem_save_info1_0;
9570         TALLOC_CTX *_mem_save_info2_0;
9571         TALLOC_CTX *_mem_save_info3_0;
9572         TALLOC_CTX *_mem_save_info4_0;
9573         TALLOC_CTX *_mem_save_info6_0;
9574         TALLOC_CTX *_mem_save_info8_0;
9575         level = ndr_pull_get_switch_value(ndr, r);
9576         if (ndr_flags & NDR_SCALARS) {
9577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9578                 if (_level != level) {
9579                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9580                 }
9581                 switch (level) {
9582                         case 1: {
9583                                 uint32_t _ptr_info1;
9584                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9585                                 if (_ptr_info1) {
9586                                         NDR_PULL_ALLOC(ndr, r->info1);
9587                                 } else {
9588                                         r->info1 = NULL;
9589                                 }
9590                         break; }
9591
9592                         case 2: {
9593                                 uint32_t _ptr_info2;
9594                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9595                                 if (_ptr_info2) {
9596                                         NDR_PULL_ALLOC(ndr, r->info2);
9597                                 } else {
9598                                         r->info2 = NULL;
9599                                 }
9600                         break; }
9601
9602                         case 3: {
9603                                 uint32_t _ptr_info3;
9604                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9605                                 if (_ptr_info3) {
9606                                         NDR_PULL_ALLOC(ndr, r->info3);
9607                                 } else {
9608                                         r->info3 = NULL;
9609                                 }
9610                         break; }
9611
9612                         case 4: {
9613                                 uint32_t _ptr_info4;
9614                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9615                                 if (_ptr_info4) {
9616                                         NDR_PULL_ALLOC(ndr, r->info4);
9617                                 } else {
9618                                         r->info4 = NULL;
9619                                 }
9620                         break; }
9621
9622                         case 6: {
9623                                 uint32_t _ptr_info6;
9624                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9625                                 if (_ptr_info6) {
9626                                         NDR_PULL_ALLOC(ndr, r->info6);
9627                                 } else {
9628                                         r->info6 = NULL;
9629                                 }
9630                         break; }
9631
9632                         case 8: {
9633                                 uint32_t _ptr_info8;
9634                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9635                                 if (_ptr_info8) {
9636                                         NDR_PULL_ALLOC(ndr, r->info8);
9637                                 } else {
9638                                         r->info8 = NULL;
9639                                 }
9640                         break; }
9641
9642                         default:
9643                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9644                 }
9645         }
9646         if (ndr_flags & NDR_BUFFERS) {
9647                 switch (level) {
9648                         case 1:
9649                                 if (r->info1) {
9650                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9652                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9654                                 }
9655                         break;
9656
9657                         case 2:
9658                                 if (r->info2) {
9659                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9660                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9661                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9662                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9663                                 }
9664                         break;
9665
9666                         case 3:
9667                                 if (r->info3) {
9668                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9669                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9670                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9671                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9672                                 }
9673                         break;
9674
9675                         case 4:
9676                                 if (r->info4) {
9677                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9678                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9679                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9680                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9681                                 }
9682                         break;
9683
9684                         case 6:
9685                                 if (r->info6) {
9686                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9687                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9688                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9689                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9690                                 }
9691                         break;
9692
9693                         case 8:
9694                                 if (r->info8) {
9695                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9696                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9697                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9698                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9699                                 }
9700                         break;
9701
9702                         default:
9703                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9704                 }
9705         }
9706         return NDR_ERR_SUCCESS;
9707 }
9708
9709 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9710 {
9711         int level;
9712         level = ndr_print_get_switch_value(ndr, r);
9713         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9714         switch (level) {
9715                 case 1:
9716                         ndr_print_ptr(ndr, "info1", r->info1);
9717                         ndr->depth++;
9718                         if (r->info1) {
9719                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9720                         }
9721                         ndr->depth--;
9722                 break;
9723
9724                 case 2:
9725                         ndr_print_ptr(ndr, "info2", r->info2);
9726                         ndr->depth++;
9727                         if (r->info2) {
9728                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9729                         }
9730                         ndr->depth--;
9731                 break;
9732
9733                 case 3:
9734                         ndr_print_ptr(ndr, "info3", r->info3);
9735                         ndr->depth++;
9736                         if (r->info3) {
9737                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9738                         }
9739                         ndr->depth--;
9740                 break;
9741
9742                 case 4:
9743                         ndr_print_ptr(ndr, "info4", r->info4);
9744                         ndr->depth++;
9745                         if (r->info4) {
9746                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9747                         }
9748                         ndr->depth--;
9749                 break;
9750
9751                 case 6:
9752                         ndr_print_ptr(ndr, "info6", r->info6);
9753                         ndr->depth++;
9754                         if (r->info6) {
9755                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9756                         }
9757                         ndr->depth--;
9758                 break;
9759
9760                 case 8:
9761                         ndr_print_ptr(ndr, "info8", r->info8);
9762                         ndr->depth++;
9763                         if (r->info8) {
9764                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9765                         }
9766                         ndr->depth--;
9767                 break;
9768
9769                 default:
9770                         ndr_print_bad_level(ndr, name, level);
9771         }
9772 }
9773
9774 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9775 {
9776         if (ndr_flags & NDR_SCALARS) {
9777                 NDR_CHECK(ndr_push_align(ndr, 4));
9778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9779                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9780                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9781         }
9782         if (ndr_flags & NDR_BUFFERS) {
9783                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9784         }
9785         return NDR_ERR_SUCCESS;
9786 }
9787
9788 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9789 {
9790         if (ndr_flags & NDR_SCALARS) {
9791                 NDR_CHECK(ndr_pull_align(ndr, 4));
9792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9793                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9794                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9795         }
9796         if (ndr_flags & NDR_BUFFERS) {
9797                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9798         }
9799         return NDR_ERR_SUCCESS;
9800 }
9801
9802 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9803 {
9804         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9805         ndr->depth++;
9806         ndr_print_uint32(ndr, "level", r->level);
9807         ndr_print_set_switch_value(ndr, &r->info, r->level);
9808         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9809         ndr->depth--;
9810 }
9811
9812 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9813 {
9814         if (ndr_flags & NDR_SCALARS) {
9815                 NDR_CHECK(ndr_push_align(ndr, 4));
9816                 {
9817                         uint32_t _flags_save_string = ndr->flags;
9818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9819                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9820                         ndr->flags = _flags_save_string;
9821                 }
9822         }
9823         if (ndr_flags & NDR_BUFFERS) {
9824                 {
9825                         uint32_t _flags_save_string = ndr->flags;
9826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9827                         if (r->driver_name) {
9828                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9829                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9830                         }
9831                         ndr->flags = _flags_save_string;
9832                 }
9833         }
9834         return NDR_ERR_SUCCESS;
9835 }
9836
9837 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9838 {
9839         uint32_t _ptr_driver_name;
9840         TALLOC_CTX *_mem_save_driver_name_0;
9841         if (ndr_flags & NDR_SCALARS) {
9842                 NDR_CHECK(ndr_pull_align(ndr, 4));
9843                 {
9844                         uint32_t _flags_save_string = ndr->flags;
9845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9847                         if (_ptr_driver_name) {
9848                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9850                         } else {
9851                                 r->driver_name = NULL;
9852                         }
9853                         ndr->flags = _flags_save_string;
9854                 }
9855         }
9856         if (ndr_flags & NDR_BUFFERS) {
9857                 {
9858                         uint32_t _flags_save_string = ndr->flags;
9859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9860                         if (r->driver_name) {
9861                                 uint32_t _relative_save_offset;
9862                                 _relative_save_offset = ndr->offset;
9863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9864                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9865                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9868                                 ndr->offset = _relative_save_offset;
9869                         }
9870                         ndr->flags = _flags_save_string;
9871                 }
9872         }
9873         return NDR_ERR_SUCCESS;
9874 }
9875
9876 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9877 {
9878         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9879         ndr->depth++;
9880         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9881         ndr->depth++;
9882         if (r->driver_name) {
9883                 ndr_print_string(ndr, "driver_name", r->driver_name);
9884         }
9885         ndr->depth--;
9886         ndr->depth--;
9887 }
9888
9889 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9890 {
9891         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9892 }
9893
9894 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9895 {
9896         if (ndr_flags & NDR_SCALARS) {
9897                 NDR_CHECK(ndr_push_align(ndr, 4));
9898                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9899                 {
9900                         uint32_t _flags_save_string = ndr->flags;
9901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9903                         ndr->flags = _flags_save_string;
9904                 }
9905                 {
9906                         uint32_t _flags_save_string = ndr->flags;
9907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9909                         ndr->flags = _flags_save_string;
9910                 }
9911                 {
9912                         uint32_t _flags_save_string = ndr->flags;
9913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9914                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9915                         ndr->flags = _flags_save_string;
9916                 }
9917                 {
9918                         uint32_t _flags_save_string = ndr->flags;
9919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9920                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9921                         ndr->flags = _flags_save_string;
9922                 }
9923                 {
9924                         uint32_t _flags_save_string = ndr->flags;
9925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9927                         ndr->flags = _flags_save_string;
9928                 }
9929         }
9930         if (ndr_flags & NDR_BUFFERS) {
9931                 {
9932                         uint32_t _flags_save_string = ndr->flags;
9933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9934                         if (r->driver_name) {
9935                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9936                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9937                         }
9938                         ndr->flags = _flags_save_string;
9939                 }
9940                 {
9941                         uint32_t _flags_save_string = ndr->flags;
9942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9943                         if (r->architecture) {
9944                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9945                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9946                         }
9947                         ndr->flags = _flags_save_string;
9948                 }
9949                 {
9950                         uint32_t _flags_save_string = ndr->flags;
9951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9952                         if (r->driver_path) {
9953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9955                         }
9956                         ndr->flags = _flags_save_string;
9957                 }
9958                 {
9959                         uint32_t _flags_save_string = ndr->flags;
9960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9961                         if (r->data_file) {
9962                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9964                         }
9965                         ndr->flags = _flags_save_string;
9966                 }
9967                 {
9968                         uint32_t _flags_save_string = ndr->flags;
9969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9970                         if (r->config_file) {
9971                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9972                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9973                         }
9974                         ndr->flags = _flags_save_string;
9975                 }
9976         }
9977         return NDR_ERR_SUCCESS;
9978 }
9979
9980 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9981 {
9982         uint32_t _ptr_driver_name;
9983         TALLOC_CTX *_mem_save_driver_name_0;
9984         uint32_t _ptr_architecture;
9985         TALLOC_CTX *_mem_save_architecture_0;
9986         uint32_t _ptr_driver_path;
9987         TALLOC_CTX *_mem_save_driver_path_0;
9988         uint32_t _ptr_data_file;
9989         TALLOC_CTX *_mem_save_data_file_0;
9990         uint32_t _ptr_config_file;
9991         TALLOC_CTX *_mem_save_config_file_0;
9992         if (ndr_flags & NDR_SCALARS) {
9993                 NDR_CHECK(ndr_pull_align(ndr, 4));
9994                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9995                 {
9996                         uint32_t _flags_save_string = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9999                         if (_ptr_driver_name) {
10000                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10001                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10002                         } else {
10003                                 r->driver_name = NULL;
10004                         }
10005                         ndr->flags = _flags_save_string;
10006                 }
10007                 {
10008                         uint32_t _flags_save_string = ndr->flags;
10009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10010                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10011                         if (_ptr_architecture) {
10012                                 NDR_PULL_ALLOC(ndr, r->architecture);
10013                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10014                         } else {
10015                                 r->architecture = NULL;
10016                         }
10017                         ndr->flags = _flags_save_string;
10018                 }
10019                 {
10020                         uint32_t _flags_save_string = ndr->flags;
10021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10022                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10023                         if (_ptr_driver_path) {
10024                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10025                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10026                         } else {
10027                                 r->driver_path = NULL;
10028                         }
10029                         ndr->flags = _flags_save_string;
10030                 }
10031                 {
10032                         uint32_t _flags_save_string = ndr->flags;
10033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10034                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10035                         if (_ptr_data_file) {
10036                                 NDR_PULL_ALLOC(ndr, r->data_file);
10037                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10038                         } else {
10039                                 r->data_file = NULL;
10040                         }
10041                         ndr->flags = _flags_save_string;
10042                 }
10043                 {
10044                         uint32_t _flags_save_string = ndr->flags;
10045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10046                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10047                         if (_ptr_config_file) {
10048                                 NDR_PULL_ALLOC(ndr, r->config_file);
10049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10050                         } else {
10051                                 r->config_file = NULL;
10052                         }
10053                         ndr->flags = _flags_save_string;
10054                 }
10055         }
10056         if (ndr_flags & NDR_BUFFERS) {
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         if (r->driver_name) {
10061                                 uint32_t _relative_save_offset;
10062                                 _relative_save_offset = ndr->offset;
10063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10064                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10065                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
10076                                 uint32_t _relative_save_offset;
10077                                 _relative_save_offset = ndr->offset;
10078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10079                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10083                                 ndr->offset = _relative_save_offset;
10084                         }
10085                         ndr->flags = _flags_save_string;
10086                 }
10087                 {
10088                         uint32_t _flags_save_string = ndr->flags;
10089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10090                         if (r->driver_path) {
10091                                 uint32_t _relative_save_offset;
10092                                 _relative_save_offset = ndr->offset;
10093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10094                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10095                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10098                                 ndr->offset = _relative_save_offset;
10099                         }
10100                         ndr->flags = _flags_save_string;
10101                 }
10102                 {
10103                         uint32_t _flags_save_string = ndr->flags;
10104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10105                         if (r->data_file) {
10106                                 uint32_t _relative_save_offset;
10107                                 _relative_save_offset = ndr->offset;
10108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10109                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10110                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10113                                 ndr->offset = _relative_save_offset;
10114                         }
10115                         ndr->flags = _flags_save_string;
10116                 }
10117                 {
10118                         uint32_t _flags_save_string = ndr->flags;
10119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10120                         if (r->config_file) {
10121                                 uint32_t _relative_save_offset;
10122                                 _relative_save_offset = ndr->offset;
10123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10124                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10125                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10128                                 ndr->offset = _relative_save_offset;
10129                         }
10130                         ndr->flags = _flags_save_string;
10131                 }
10132         }
10133         return NDR_ERR_SUCCESS;
10134 }
10135
10136 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10137 {
10138         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10139         ndr->depth++;
10140         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10141         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10142         ndr->depth++;
10143         if (r->driver_name) {
10144                 ndr_print_string(ndr, "driver_name", r->driver_name);
10145         }
10146         ndr->depth--;
10147         ndr_print_ptr(ndr, "architecture", r->architecture);
10148         ndr->depth++;
10149         if (r->architecture) {
10150                 ndr_print_string(ndr, "architecture", r->architecture);
10151         }
10152         ndr->depth--;
10153         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10154         ndr->depth++;
10155         if (r->driver_path) {
10156                 ndr_print_string(ndr, "driver_path", r->driver_path);
10157         }
10158         ndr->depth--;
10159         ndr_print_ptr(ndr, "data_file", r->data_file);
10160         ndr->depth++;
10161         if (r->data_file) {
10162                 ndr_print_string(ndr, "data_file", r->data_file);
10163         }
10164         ndr->depth--;
10165         ndr_print_ptr(ndr, "config_file", r->config_file);
10166         ndr->depth++;
10167         if (r->config_file) {
10168                 ndr_print_string(ndr, "config_file", r->config_file);
10169         }
10170         ndr->depth--;
10171         ndr->depth--;
10172 }
10173
10174 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10175 {
10176         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10177 }
10178
10179 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10180 {
10181         if (ndr_flags & NDR_SCALARS) {
10182                 NDR_CHECK(ndr_push_align(ndr, 4));
10183                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10184                 {
10185                         uint32_t _flags_save_string = ndr->flags;
10186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10187                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10188                         ndr->flags = _flags_save_string;
10189                 }
10190                 {
10191                         uint32_t _flags_save_string = ndr->flags;
10192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10193                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10194                         ndr->flags = _flags_save_string;
10195                 }
10196                 {
10197                         uint32_t _flags_save_string = ndr->flags;
10198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10200                         ndr->flags = _flags_save_string;
10201                 }
10202                 {
10203                         uint32_t _flags_save_string = ndr->flags;
10204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10205                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10206                         ndr->flags = _flags_save_string;
10207                 }
10208                 {
10209                         uint32_t _flags_save_string = ndr->flags;
10210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10211                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10212                         ndr->flags = _flags_save_string;
10213                 }
10214                 {
10215                         uint32_t _flags_save_string = ndr->flags;
10216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10217                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10218                         ndr->flags = _flags_save_string;
10219                 }
10220                 {
10221                         uint32_t _flags_save_string_array = ndr->flags;
10222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10224                         ndr->flags = _flags_save_string_array;
10225                 }
10226                 {
10227                         uint32_t _flags_save_string = ndr->flags;
10228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10230                         ndr->flags = _flags_save_string;
10231                 }
10232                 {
10233                         uint32_t _flags_save_string = ndr->flags;
10234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10236                         ndr->flags = _flags_save_string;
10237                 }
10238         }
10239         if (ndr_flags & NDR_BUFFERS) {
10240                 {
10241                         uint32_t _flags_save_string = ndr->flags;
10242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10243                         if (r->driver_name) {
10244                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10245                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10246                         }
10247                         ndr->flags = _flags_save_string;
10248                 }
10249                 {
10250                         uint32_t _flags_save_string = ndr->flags;
10251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10252                         if (r->architecture) {
10253                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10254                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10255                         }
10256                         ndr->flags = _flags_save_string;
10257                 }
10258                 {
10259                         uint32_t _flags_save_string = ndr->flags;
10260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10261                         if (r->driver_path) {
10262                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10263                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10271                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10273                         }
10274                         ndr->flags = _flags_save_string;
10275                 }
10276                 {
10277                         uint32_t _flags_save_string = ndr->flags;
10278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10279                         if (r->config_file) {
10280                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10281                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10282                         }
10283                         ndr->flags = _flags_save_string;
10284                 }
10285                 {
10286                         uint32_t _flags_save_string = ndr->flags;
10287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10288                         if (r->help_file) {
10289                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10291                         }
10292                         ndr->flags = _flags_save_string;
10293                 }
10294                 {
10295                         uint32_t _flags_save_string_array = ndr->flags;
10296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10297                         if (r->dependent_files) {
10298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10299                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10300                         }
10301                         ndr->flags = _flags_save_string_array;
10302                 }
10303                 {
10304                         uint32_t _flags_save_string = ndr->flags;
10305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10306                         if (r->monitor_name) {
10307                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10309                         }
10310                         ndr->flags = _flags_save_string;
10311                 }
10312                 {
10313                         uint32_t _flags_save_string = ndr->flags;
10314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10315                         if (r->default_datatype) {
10316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10318                         }
10319                         ndr->flags = _flags_save_string;
10320                 }
10321         }
10322         return NDR_ERR_SUCCESS;
10323 }
10324
10325 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10326 {
10327         uint32_t _ptr_driver_name;
10328         TALLOC_CTX *_mem_save_driver_name_0;
10329         uint32_t _ptr_architecture;
10330         TALLOC_CTX *_mem_save_architecture_0;
10331         uint32_t _ptr_driver_path;
10332         TALLOC_CTX *_mem_save_driver_path_0;
10333         uint32_t _ptr_data_file;
10334         TALLOC_CTX *_mem_save_data_file_0;
10335         uint32_t _ptr_config_file;
10336         TALLOC_CTX *_mem_save_config_file_0;
10337         uint32_t _ptr_help_file;
10338         TALLOC_CTX *_mem_save_help_file_0;
10339         uint32_t _ptr_dependent_files;
10340         TALLOC_CTX *_mem_save_dependent_files_0;
10341         uint32_t _ptr_monitor_name;
10342         TALLOC_CTX *_mem_save_monitor_name_0;
10343         uint32_t _ptr_default_datatype;
10344         TALLOC_CTX *_mem_save_default_datatype_0;
10345         if (ndr_flags & NDR_SCALARS) {
10346                 NDR_CHECK(ndr_pull_align(ndr, 4));
10347                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10348                 {
10349                         uint32_t _flags_save_string = ndr->flags;
10350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10352                         if (_ptr_driver_name) {
10353                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10355                         } else {
10356                                 r->driver_name = NULL;
10357                         }
10358                         ndr->flags = _flags_save_string;
10359                 }
10360                 {
10361                         uint32_t _flags_save_string = ndr->flags;
10362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10363                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10364                         if (_ptr_architecture) {
10365                                 NDR_PULL_ALLOC(ndr, r->architecture);
10366                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10367                         } else {
10368                                 r->architecture = NULL;
10369                         }
10370                         ndr->flags = _flags_save_string;
10371                 }
10372                 {
10373                         uint32_t _flags_save_string = ndr->flags;
10374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10376                         if (_ptr_driver_path) {
10377                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10379                         } else {
10380                                 r->driver_path = NULL;
10381                         }
10382                         ndr->flags = _flags_save_string;
10383                 }
10384                 {
10385                         uint32_t _flags_save_string = ndr->flags;
10386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10387                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10388                         if (_ptr_data_file) {
10389                                 NDR_PULL_ALLOC(ndr, r->data_file);
10390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10391                         } else {
10392                                 r->data_file = NULL;
10393                         }
10394                         ndr->flags = _flags_save_string;
10395                 }
10396                 {
10397                         uint32_t _flags_save_string = ndr->flags;
10398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10400                         if (_ptr_config_file) {
10401                                 NDR_PULL_ALLOC(ndr, r->config_file);
10402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10403                         } else {
10404                                 r->config_file = NULL;
10405                         }
10406                         ndr->flags = _flags_save_string;
10407                 }
10408                 {
10409                         uint32_t _flags_save_string = ndr->flags;
10410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10411                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10412                         if (_ptr_help_file) {
10413                                 NDR_PULL_ALLOC(ndr, r->help_file);
10414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10415                         } else {
10416                                 r->help_file = NULL;
10417                         }
10418                         ndr->flags = _flags_save_string;
10419                 }
10420                 {
10421                         uint32_t _flags_save_string_array = ndr->flags;
10422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10424                         if (_ptr_dependent_files) {
10425                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10427                         } else {
10428                                 r->dependent_files = NULL;
10429                         }
10430                         ndr->flags = _flags_save_string_array;
10431                 }
10432                 {
10433                         uint32_t _flags_save_string = ndr->flags;
10434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10435                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10436                         if (_ptr_monitor_name) {
10437                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10439                         } else {
10440                                 r->monitor_name = NULL;
10441                         }
10442                         ndr->flags = _flags_save_string;
10443                 }
10444                 {
10445                         uint32_t _flags_save_string = ndr->flags;
10446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10447                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10448                         if (_ptr_default_datatype) {
10449                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10451                         } else {
10452                                 r->default_datatype = NULL;
10453                         }
10454                         ndr->flags = _flags_save_string;
10455                 }
10456         }
10457         if (ndr_flags & NDR_BUFFERS) {
10458                 {
10459                         uint32_t _flags_save_string = ndr->flags;
10460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10461                         if (r->driver_name) {
10462                                 uint32_t _relative_save_offset;
10463                                 _relative_save_offset = ndr->offset;
10464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10465                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10466                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
10477                                 uint32_t _relative_save_offset;
10478                                 _relative_save_offset = ndr->offset;
10479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10480                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
10492                                 uint32_t _relative_save_offset;
10493                                 _relative_save_offset = ndr->offset;
10494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10495                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10496                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10499                                 ndr->offset = _relative_save_offset;
10500                         }
10501                         ndr->flags = _flags_save_string;
10502                 }
10503                 {
10504                         uint32_t _flags_save_string = ndr->flags;
10505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10506                         if (r->data_file) {
10507                                 uint32_t _relative_save_offset;
10508                                 _relative_save_offset = ndr->offset;
10509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10510                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10511                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10512                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10514                                 ndr->offset = _relative_save_offset;
10515                         }
10516                         ndr->flags = _flags_save_string;
10517                 }
10518                 {
10519                         uint32_t _flags_save_string = ndr->flags;
10520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10521                         if (r->config_file) {
10522                                 uint32_t _relative_save_offset;
10523                                 _relative_save_offset = ndr->offset;
10524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10525                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_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->help_file) {
10537                                 uint32_t _relative_save_offset;
10538                                 _relative_save_offset = ndr->offset;
10539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10540                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10541                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10544                                 ndr->offset = _relative_save_offset;
10545                         }
10546                         ndr->flags = _flags_save_string;
10547                 }
10548                 {
10549                         uint32_t _flags_save_string_array = ndr->flags;
10550                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10551                         if (r->dependent_files) {
10552                                 uint32_t _relative_save_offset;
10553                                 _relative_save_offset = ndr->offset;
10554                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10555                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10556                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10557                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10558                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10559                                 ndr->offset = _relative_save_offset;
10560                         }
10561                         ndr->flags = _flags_save_string_array;
10562                 }
10563                 {
10564                         uint32_t _flags_save_string = ndr->flags;
10565                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10566                         if (r->monitor_name) {
10567                                 uint32_t _relative_save_offset;
10568                                 _relative_save_offset = ndr->offset;
10569                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10570                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10571                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10572                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10573                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10574                                 ndr->offset = _relative_save_offset;
10575                         }
10576                         ndr->flags = _flags_save_string;
10577                 }
10578                 {
10579                         uint32_t _flags_save_string = ndr->flags;
10580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10581                         if (r->default_datatype) {
10582                                 uint32_t _relative_save_offset;
10583                                 _relative_save_offset = ndr->offset;
10584                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10585                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10586                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10587                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10588                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10589                                 ndr->offset = _relative_save_offset;
10590                         }
10591                         ndr->flags = _flags_save_string;
10592                 }
10593         }
10594         return NDR_ERR_SUCCESS;
10595 }
10596
10597 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10598 {
10599         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10600         ndr->depth++;
10601         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10602         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10603         ndr->depth++;
10604         if (r->driver_name) {
10605                 ndr_print_string(ndr, "driver_name", r->driver_name);
10606         }
10607         ndr->depth--;
10608         ndr_print_ptr(ndr, "architecture", r->architecture);
10609         ndr->depth++;
10610         if (r->architecture) {
10611                 ndr_print_string(ndr, "architecture", r->architecture);
10612         }
10613         ndr->depth--;
10614         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10615         ndr->depth++;
10616         if (r->driver_path) {
10617                 ndr_print_string(ndr, "driver_path", r->driver_path);
10618         }
10619         ndr->depth--;
10620         ndr_print_ptr(ndr, "data_file", r->data_file);
10621         ndr->depth++;
10622         if (r->data_file) {
10623                 ndr_print_string(ndr, "data_file", r->data_file);
10624         }
10625         ndr->depth--;
10626         ndr_print_ptr(ndr, "config_file", r->config_file);
10627         ndr->depth++;
10628         if (r->config_file) {
10629                 ndr_print_string(ndr, "config_file", r->config_file);
10630         }
10631         ndr->depth--;
10632         ndr_print_ptr(ndr, "help_file", r->help_file);
10633         ndr->depth++;
10634         if (r->help_file) {
10635                 ndr_print_string(ndr, "help_file", r->help_file);
10636         }
10637         ndr->depth--;
10638         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10639         ndr->depth++;
10640         if (r->dependent_files) {
10641                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10642         }
10643         ndr->depth--;
10644         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10645         ndr->depth++;
10646         if (r->monitor_name) {
10647                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10648         }
10649         ndr->depth--;
10650         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10651         ndr->depth++;
10652         if (r->default_datatype) {
10653                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10654         }
10655         ndr->depth--;
10656         ndr->depth--;
10657 }
10658
10659 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10660 {
10661         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10662 }
10663
10664 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10665 {
10666         if (ndr_flags & NDR_SCALARS) {
10667                 NDR_CHECK(ndr_push_align(ndr, 4));
10668                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10669                 {
10670                         uint32_t _flags_save_string = ndr->flags;
10671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10672                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10673                         ndr->flags = _flags_save_string;
10674                 }
10675                 {
10676                         uint32_t _flags_save_string = ndr->flags;
10677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10678                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10679                         ndr->flags = _flags_save_string;
10680                 }
10681                 {
10682                         uint32_t _flags_save_string = ndr->flags;
10683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10684                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10685                         ndr->flags = _flags_save_string;
10686                 }
10687                 {
10688                         uint32_t _flags_save_string = ndr->flags;
10689                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10690                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10691                         ndr->flags = _flags_save_string;
10692                 }
10693                 {
10694                         uint32_t _flags_save_string = ndr->flags;
10695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10696                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10697                         ndr->flags = _flags_save_string;
10698                 }
10699                 {
10700                         uint32_t _flags_save_string = ndr->flags;
10701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10702                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10703                         ndr->flags = _flags_save_string;
10704                 }
10705                 {
10706                         uint32_t _flags_save_string_array = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10709                         ndr->flags = _flags_save_string_array;
10710                 }
10711                 {
10712                         uint32_t _flags_save_string = ndr->flags;
10713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10714                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10715                         ndr->flags = _flags_save_string;
10716                 }
10717                 {
10718                         uint32_t _flags_save_string = ndr->flags;
10719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string_array = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10727                         ndr->flags = _flags_save_string_array;
10728                 }
10729         }
10730         if (ndr_flags & NDR_BUFFERS) {
10731                 {
10732                         uint32_t _flags_save_string = ndr->flags;
10733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10734                         if (r->driver_name) {
10735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10737                         }
10738                         ndr->flags = _flags_save_string;
10739                 }
10740                 {
10741                         uint32_t _flags_save_string = ndr->flags;
10742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10743                         if (r->architecture) {
10744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10746                         }
10747                         ndr->flags = _flags_save_string;
10748                 }
10749                 {
10750                         uint32_t _flags_save_string = ndr->flags;
10751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10752                         if (r->driver_path) {
10753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10764                         }
10765                         ndr->flags = _flags_save_string;
10766                 }
10767                 {
10768                         uint32_t _flags_save_string = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         if (r->config_file) {
10771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10773                         }
10774                         ndr->flags = _flags_save_string;
10775                 }
10776                 {
10777                         uint32_t _flags_save_string = ndr->flags;
10778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10779                         if (r->help_file) {
10780                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10782                         }
10783                         ndr->flags = _flags_save_string;
10784                 }
10785                 {
10786                         uint32_t _flags_save_string_array = ndr->flags;
10787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10788                         if (r->dependent_files) {
10789                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10790                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10791                         }
10792                         ndr->flags = _flags_save_string_array;
10793                 }
10794                 {
10795                         uint32_t _flags_save_string = ndr->flags;
10796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10797                         if (r->monitor_name) {
10798                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10799                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10800                         }
10801                         ndr->flags = _flags_save_string;
10802                 }
10803                 {
10804                         uint32_t _flags_save_string = ndr->flags;
10805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10806                         if (r->default_datatype) {
10807                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10808                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10809                         }
10810                         ndr->flags = _flags_save_string;
10811                 }
10812                 {
10813                         uint32_t _flags_save_string_array = ndr->flags;
10814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10815                         if (r->previous_names) {
10816                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10817                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10818                         }
10819                         ndr->flags = _flags_save_string_array;
10820                 }
10821         }
10822         return NDR_ERR_SUCCESS;
10823 }
10824
10825 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10826 {
10827         uint32_t _ptr_driver_name;
10828         TALLOC_CTX *_mem_save_driver_name_0;
10829         uint32_t _ptr_architecture;
10830         TALLOC_CTX *_mem_save_architecture_0;
10831         uint32_t _ptr_driver_path;
10832         TALLOC_CTX *_mem_save_driver_path_0;
10833         uint32_t _ptr_data_file;
10834         TALLOC_CTX *_mem_save_data_file_0;
10835         uint32_t _ptr_config_file;
10836         TALLOC_CTX *_mem_save_config_file_0;
10837         uint32_t _ptr_help_file;
10838         TALLOC_CTX *_mem_save_help_file_0;
10839         uint32_t _ptr_dependent_files;
10840         TALLOC_CTX *_mem_save_dependent_files_0;
10841         uint32_t _ptr_monitor_name;
10842         TALLOC_CTX *_mem_save_monitor_name_0;
10843         uint32_t _ptr_default_datatype;
10844         TALLOC_CTX *_mem_save_default_datatype_0;
10845         uint32_t _ptr_previous_names;
10846         TALLOC_CTX *_mem_save_previous_names_0;
10847         if (ndr_flags & NDR_SCALARS) {
10848                 NDR_CHECK(ndr_pull_align(ndr, 4));
10849                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10850                 {
10851                         uint32_t _flags_save_string = ndr->flags;
10852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10854                         if (_ptr_driver_name) {
10855                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10857                         } else {
10858                                 r->driver_name = NULL;
10859                         }
10860                         ndr->flags = _flags_save_string;
10861                 }
10862                 {
10863                         uint32_t _flags_save_string = ndr->flags;
10864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10866                         if (_ptr_architecture) {
10867                                 NDR_PULL_ALLOC(ndr, r->architecture);
10868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10869                         } else {
10870                                 r->architecture = NULL;
10871                         }
10872                         ndr->flags = _flags_save_string;
10873                 }
10874                 {
10875                         uint32_t _flags_save_string = ndr->flags;
10876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10877                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10878                         if (_ptr_driver_path) {
10879                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10881                         } else {
10882                                 r->driver_path = NULL;
10883                         }
10884                         ndr->flags = _flags_save_string;
10885                 }
10886                 {
10887                         uint32_t _flags_save_string = ndr->flags;
10888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10889                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10890                         if (_ptr_data_file) {
10891                                 NDR_PULL_ALLOC(ndr, r->data_file);
10892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10893                         } else {
10894                                 r->data_file = NULL;
10895                         }
10896                         ndr->flags = _flags_save_string;
10897                 }
10898                 {
10899                         uint32_t _flags_save_string = ndr->flags;
10900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10902                         if (_ptr_config_file) {
10903                                 NDR_PULL_ALLOC(ndr, r->config_file);
10904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10905                         } else {
10906                                 r->config_file = NULL;
10907                         }
10908                         ndr->flags = _flags_save_string;
10909                 }
10910                 {
10911                         uint32_t _flags_save_string = ndr->flags;
10912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10914                         if (_ptr_help_file) {
10915                                 NDR_PULL_ALLOC(ndr, r->help_file);
10916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10917                         } else {
10918                                 r->help_file = NULL;
10919                         }
10920                         ndr->flags = _flags_save_string;
10921                 }
10922                 {
10923                         uint32_t _flags_save_string_array = ndr->flags;
10924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10926                         if (_ptr_dependent_files) {
10927                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10929                         } else {
10930                                 r->dependent_files = NULL;
10931                         }
10932                         ndr->flags = _flags_save_string_array;
10933                 }
10934                 {
10935                         uint32_t _flags_save_string = ndr->flags;
10936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10937                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10938                         if (_ptr_monitor_name) {
10939                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10941                         } else {
10942                                 r->monitor_name = NULL;
10943                         }
10944                         ndr->flags = _flags_save_string;
10945                 }
10946                 {
10947                         uint32_t _flags_save_string = ndr->flags;
10948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10950                         if (_ptr_default_datatype) {
10951                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10953                         } else {
10954                                 r->default_datatype = NULL;
10955                         }
10956                         ndr->flags = _flags_save_string;
10957                 }
10958                 {
10959                         uint32_t _flags_save_string_array = ndr->flags;
10960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10962                         if (_ptr_previous_names) {
10963                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10965                         } else {
10966                                 r->previous_names = NULL;
10967                         }
10968                         ndr->flags = _flags_save_string_array;
10969                 }
10970         }
10971         if (ndr_flags & NDR_BUFFERS) {
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         if (r->driver_name) {
10976                                 uint32_t _relative_save_offset;
10977                                 _relative_save_offset = ndr->offset;
10978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10979                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10980                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10981                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
10991                                 uint32_t _relative_save_offset;
10992                                 _relative_save_offset = ndr->offset;
10993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10994                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10995                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
11006                                 uint32_t _relative_save_offset;
11007                                 _relative_save_offset = ndr->offset;
11008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11009                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11013                                 ndr->offset = _relative_save_offset;
11014                         }
11015                         ndr->flags = _flags_save_string;
11016                 }
11017                 {
11018                         uint32_t _flags_save_string = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         if (r->data_file) {
11021                                 uint32_t _relative_save_offset;
11022                                 _relative_save_offset = ndr->offset;
11023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11024                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11025                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11028                                 ndr->offset = _relative_save_offset;
11029                         }
11030                         ndr->flags = _flags_save_string;
11031                 }
11032                 {
11033                         uint32_t _flags_save_string = ndr->flags;
11034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11035                         if (r->config_file) {
11036                                 uint32_t _relative_save_offset;
11037                                 _relative_save_offset = ndr->offset;
11038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11039                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11040                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_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->help_file) {
11051                                 uint32_t _relative_save_offset;
11052                                 _relative_save_offset = ndr->offset;
11053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11054                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11055                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_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->dependent_files) {
11066                                 uint32_t _relative_save_offset;
11067                                 _relative_save_offset = ndr->offset;
11068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11069                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11070                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11071                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11073                                 ndr->offset = _relative_save_offset;
11074                         }
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077                 {
11078                         uint32_t _flags_save_string = ndr->flags;
11079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11080                         if (r->monitor_name) {
11081                                 uint32_t _relative_save_offset;
11082                                 _relative_save_offset = ndr->offset;
11083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11084                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11085                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11086                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11088                                 ndr->offset = _relative_save_offset;
11089                         }
11090                         ndr->flags = _flags_save_string;
11091                 }
11092                 {
11093                         uint32_t _flags_save_string = ndr->flags;
11094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11095                         if (r->default_datatype) {
11096                                 uint32_t _relative_save_offset;
11097                                 _relative_save_offset = ndr->offset;
11098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11099                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11100                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11103                                 ndr->offset = _relative_save_offset;
11104                         }
11105                         ndr->flags = _flags_save_string;
11106                 }
11107                 {
11108                         uint32_t _flags_save_string_array = ndr->flags;
11109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11110                         if (r->previous_names) {
11111                                 uint32_t _relative_save_offset;
11112                                 _relative_save_offset = ndr->offset;
11113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11114                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11115                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11116                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11118                                 ndr->offset = _relative_save_offset;
11119                         }
11120                         ndr->flags = _flags_save_string_array;
11121                 }
11122         }
11123         return NDR_ERR_SUCCESS;
11124 }
11125
11126 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11127 {
11128         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11129         ndr->depth++;
11130         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11131         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11132         ndr->depth++;
11133         if (r->driver_name) {
11134                 ndr_print_string(ndr, "driver_name", r->driver_name);
11135         }
11136         ndr->depth--;
11137         ndr_print_ptr(ndr, "architecture", r->architecture);
11138         ndr->depth++;
11139         if (r->architecture) {
11140                 ndr_print_string(ndr, "architecture", r->architecture);
11141         }
11142         ndr->depth--;
11143         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11144         ndr->depth++;
11145         if (r->driver_path) {
11146                 ndr_print_string(ndr, "driver_path", r->driver_path);
11147         }
11148         ndr->depth--;
11149         ndr_print_ptr(ndr, "data_file", r->data_file);
11150         ndr->depth++;
11151         if (r->data_file) {
11152                 ndr_print_string(ndr, "data_file", r->data_file);
11153         }
11154         ndr->depth--;
11155         ndr_print_ptr(ndr, "config_file", r->config_file);
11156         ndr->depth++;
11157         if (r->config_file) {
11158                 ndr_print_string(ndr, "config_file", r->config_file);
11159         }
11160         ndr->depth--;
11161         ndr_print_ptr(ndr, "help_file", r->help_file);
11162         ndr->depth++;
11163         if (r->help_file) {
11164                 ndr_print_string(ndr, "help_file", r->help_file);
11165         }
11166         ndr->depth--;
11167         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11168         ndr->depth++;
11169         if (r->dependent_files) {
11170                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11171         }
11172         ndr->depth--;
11173         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11174         ndr->depth++;
11175         if (r->monitor_name) {
11176                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11177         }
11178         ndr->depth--;
11179         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11180         ndr->depth++;
11181         if (r->default_datatype) {
11182                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11183         }
11184         ndr->depth--;
11185         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11186         ndr->depth++;
11187         if (r->previous_names) {
11188                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11189         }
11190         ndr->depth--;
11191         ndr->depth--;
11192 }
11193
11194 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11195 {
11196         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11197 }
11198
11199 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11200 {
11201         if (ndr_flags & NDR_SCALARS) {
11202                 NDR_CHECK(ndr_push_align(ndr, 4));
11203                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11204                 {
11205                         uint32_t _flags_save_string = ndr->flags;
11206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11207                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11208                         ndr->flags = _flags_save_string;
11209                 }
11210                 {
11211                         uint32_t _flags_save_string = ndr->flags;
11212                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11213                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11214                         ndr->flags = _flags_save_string;
11215                 }
11216                 {
11217                         uint32_t _flags_save_string = ndr->flags;
11218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11219                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11220                         ndr->flags = _flags_save_string;
11221                 }
11222                 {
11223                         uint32_t _flags_save_string = ndr->flags;
11224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11225                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11226                         ndr->flags = _flags_save_string;
11227                 }
11228                 {
11229                         uint32_t _flags_save_string = ndr->flags;
11230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11231                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11232                         ndr->flags = _flags_save_string;
11233                 }
11234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11237         }
11238         if (ndr_flags & NDR_BUFFERS) {
11239                 {
11240                         uint32_t _flags_save_string = ndr->flags;
11241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11242                         if (r->driver_name) {
11243                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11244                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11245                         }
11246                         ndr->flags = _flags_save_string;
11247                 }
11248                 {
11249                         uint32_t _flags_save_string = ndr->flags;
11250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11251                         if (r->architecture) {
11252                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11253                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11254                         }
11255                         ndr->flags = _flags_save_string;
11256                 }
11257                 {
11258                         uint32_t _flags_save_string = ndr->flags;
11259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11260                         if (r->driver_path) {
11261                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11262                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11263                         }
11264                         ndr->flags = _flags_save_string;
11265                 }
11266                 {
11267                         uint32_t _flags_save_string = ndr->flags;
11268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11269                         if (r->data_file) {
11270                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11271                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11272                         }
11273                         ndr->flags = _flags_save_string;
11274                 }
11275                 {
11276                         uint32_t _flags_save_string = ndr->flags;
11277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11278                         if (r->config_file) {
11279                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11280                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11281                         }
11282                         ndr->flags = _flags_save_string;
11283                 }
11284         }
11285         return NDR_ERR_SUCCESS;
11286 }
11287
11288 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11289 {
11290         uint32_t _ptr_driver_name;
11291         TALLOC_CTX *_mem_save_driver_name_0;
11292         uint32_t _ptr_architecture;
11293         TALLOC_CTX *_mem_save_architecture_0;
11294         uint32_t _ptr_driver_path;
11295         TALLOC_CTX *_mem_save_driver_path_0;
11296         uint32_t _ptr_data_file;
11297         TALLOC_CTX *_mem_save_data_file_0;
11298         uint32_t _ptr_config_file;
11299         TALLOC_CTX *_mem_save_config_file_0;
11300         if (ndr_flags & NDR_SCALARS) {
11301                 NDR_CHECK(ndr_pull_align(ndr, 4));
11302                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11303                 {
11304                         uint32_t _flags_save_string = ndr->flags;
11305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11306                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11307                         if (_ptr_driver_name) {
11308                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11309                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11310                         } else {
11311                                 r->driver_name = NULL;
11312                         }
11313                         ndr->flags = _flags_save_string;
11314                 }
11315                 {
11316                         uint32_t _flags_save_string = ndr->flags;
11317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11318                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11319                         if (_ptr_architecture) {
11320                                 NDR_PULL_ALLOC(ndr, r->architecture);
11321                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11322                         } else {
11323                                 r->architecture = NULL;
11324                         }
11325                         ndr->flags = _flags_save_string;
11326                 }
11327                 {
11328                         uint32_t _flags_save_string = ndr->flags;
11329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11331                         if (_ptr_driver_path) {
11332                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11334                         } else {
11335                                 r->driver_path = NULL;
11336                         }
11337                         ndr->flags = _flags_save_string;
11338                 }
11339                 {
11340                         uint32_t _flags_save_string = ndr->flags;
11341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11343                         if (_ptr_data_file) {
11344                                 NDR_PULL_ALLOC(ndr, r->data_file);
11345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11346                         } else {
11347                                 r->data_file = NULL;
11348                         }
11349                         ndr->flags = _flags_save_string;
11350                 }
11351                 {
11352                         uint32_t _flags_save_string = ndr->flags;
11353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11355                         if (_ptr_config_file) {
11356                                 NDR_PULL_ALLOC(ndr, r->config_file);
11357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11358                         } else {
11359                                 r->config_file = NULL;
11360                         }
11361                         ndr->flags = _flags_save_string;
11362                 }
11363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11366         }
11367         if (ndr_flags & NDR_BUFFERS) {
11368                 {
11369                         uint32_t _flags_save_string = ndr->flags;
11370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11371                         if (r->driver_name) {
11372                                 uint32_t _relative_save_offset;
11373                                 _relative_save_offset = ndr->offset;
11374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11375                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11376                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
11387                                 uint32_t _relative_save_offset;
11388                                 _relative_save_offset = ndr->offset;
11389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11390                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11391                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11394                                 ndr->offset = _relative_save_offset;
11395                         }
11396                         ndr->flags = _flags_save_string;
11397                 }
11398                 {
11399                         uint32_t _flags_save_string = ndr->flags;
11400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11401                         if (r->driver_path) {
11402                                 uint32_t _relative_save_offset;
11403                                 _relative_save_offset = ndr->offset;
11404                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11405                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11406                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11407                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11408                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11409                                 ndr->offset = _relative_save_offset;
11410                         }
11411                         ndr->flags = _flags_save_string;
11412                 }
11413                 {
11414                         uint32_t _flags_save_string = ndr->flags;
11415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11416                         if (r->data_file) {
11417                                 uint32_t _relative_save_offset;
11418                                 _relative_save_offset = ndr->offset;
11419                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11420                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11421                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11422                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11423                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11424                                 ndr->offset = _relative_save_offset;
11425                         }
11426                         ndr->flags = _flags_save_string;
11427                 }
11428                 {
11429                         uint32_t _flags_save_string = ndr->flags;
11430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11431                         if (r->config_file) {
11432                                 uint32_t _relative_save_offset;
11433                                 _relative_save_offset = ndr->offset;
11434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11435                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11436                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11439                                 ndr->offset = _relative_save_offset;
11440                         }
11441                         ndr->flags = _flags_save_string;
11442                 }
11443         }
11444         return NDR_ERR_SUCCESS;
11445 }
11446
11447 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11448 {
11449         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11450         ndr->depth++;
11451         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11452         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11453         ndr->depth++;
11454         if (r->driver_name) {
11455                 ndr_print_string(ndr, "driver_name", r->driver_name);
11456         }
11457         ndr->depth--;
11458         ndr_print_ptr(ndr, "architecture", r->architecture);
11459         ndr->depth++;
11460         if (r->architecture) {
11461                 ndr_print_string(ndr, "architecture", r->architecture);
11462         }
11463         ndr->depth--;
11464         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11465         ndr->depth++;
11466         if (r->driver_path) {
11467                 ndr_print_string(ndr, "driver_path", r->driver_path);
11468         }
11469         ndr->depth--;
11470         ndr_print_ptr(ndr, "data_file", r->data_file);
11471         ndr->depth++;
11472         if (r->data_file) {
11473                 ndr_print_string(ndr, "data_file", r->data_file);
11474         }
11475         ndr->depth--;
11476         ndr_print_ptr(ndr, "config_file", r->config_file);
11477         ndr->depth++;
11478         if (r->config_file) {
11479                 ndr_print_string(ndr, "config_file", r->config_file);
11480         }
11481         ndr->depth--;
11482         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11483         ndr_print_uint32(ndr, "config_version", r->config_version);
11484         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11485         ndr->depth--;
11486 }
11487
11488 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11489 {
11490         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11491 }
11492
11493 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11494 {
11495         if (ndr_flags & NDR_SCALARS) {
11496                 NDR_CHECK(ndr_push_align(ndr, 8));
11497                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11498                 {
11499                         uint32_t _flags_save_string = ndr->flags;
11500                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11501                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11502                         ndr->flags = _flags_save_string;
11503                 }
11504                 {
11505                         uint32_t _flags_save_string = ndr->flags;
11506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11508                         ndr->flags = _flags_save_string;
11509                 }
11510                 {
11511                         uint32_t _flags_save_string = ndr->flags;
11512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11520                         ndr->flags = _flags_save_string;
11521                 }
11522                 {
11523                         uint32_t _flags_save_string = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11526                         ndr->flags = _flags_save_string;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string_array = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11538                         ndr->flags = _flags_save_string_array;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11544                         ndr->flags = _flags_save_string;
11545                 }
11546                 {
11547                         uint32_t _flags_save_string = ndr->flags;
11548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string_array = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11556                         ndr->flags = _flags_save_string_array;
11557                 }
11558                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11559                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11560                 {
11561                         uint32_t _flags_save_string = ndr->flags;
11562                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11563                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11564                         ndr->flags = _flags_save_string;
11565                 }
11566                 {
11567                         uint32_t _flags_save_string = ndr->flags;
11568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11570                         ndr->flags = _flags_save_string;
11571                 }
11572                 {
11573                         uint32_t _flags_save_string = ndr->flags;
11574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11576                         ndr->flags = _flags_save_string;
11577                 }
11578                 {
11579                         uint32_t _flags_save_string = ndr->flags;
11580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11582                         ndr->flags = _flags_save_string;
11583                 }
11584         }
11585         if (ndr_flags & NDR_BUFFERS) {
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         if (r->driver_name) {
11590                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11591                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11592                         }
11593                         ndr->flags = _flags_save_string;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         if (r->architecture) {
11599                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11600                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11601                         }
11602                         ndr->flags = _flags_save_string;
11603                 }
11604                 {
11605                         uint32_t _flags_save_string = ndr->flags;
11606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11607                         if (r->driver_path) {
11608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
11617                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         if (r->config_file) {
11626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11628                         }
11629                         ndr->flags = _flags_save_string;
11630                 }
11631                 {
11632                         uint32_t _flags_save_string = ndr->flags;
11633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11634                         if (r->help_file) {
11635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11637                         }
11638                         ndr->flags = _flags_save_string;
11639                 }
11640                 {
11641                         uint32_t _flags_save_string_array = ndr->flags;
11642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11643                         if (r->dependent_files) {
11644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11645                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11646                         }
11647                         ndr->flags = _flags_save_string_array;
11648                 }
11649                 {
11650                         uint32_t _flags_save_string = ndr->flags;
11651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11652                         if (r->monitor_name) {
11653                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->default_datatype) {
11662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11664                         }
11665                         ndr->flags = _flags_save_string;
11666                 }
11667                 {
11668                         uint32_t _flags_save_string_array = ndr->flags;
11669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11670                         if (r->previous_names) {
11671                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11672                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11673                         }
11674                         ndr->flags = _flags_save_string_array;
11675                 }
11676                 {
11677                         uint32_t _flags_save_string = ndr->flags;
11678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11679                         if (r->manufacturer_name) {
11680                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11681                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11682                         }
11683                         ndr->flags = _flags_save_string;
11684                 }
11685                 {
11686                         uint32_t _flags_save_string = ndr->flags;
11687                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11688                         if (r->manufacturer_url) {
11689                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11690                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11691                         }
11692                         ndr->flags = _flags_save_string;
11693                 }
11694                 {
11695                         uint32_t _flags_save_string = ndr->flags;
11696                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11697                         if (r->hardware_id) {
11698                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11699                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11700                         }
11701                         ndr->flags = _flags_save_string;
11702                 }
11703                 {
11704                         uint32_t _flags_save_string = ndr->flags;
11705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11706                         if (r->provider) {
11707                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11708                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11709                         }
11710                         ndr->flags = _flags_save_string;
11711                 }
11712         }
11713         return NDR_ERR_SUCCESS;
11714 }
11715
11716 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11717 {
11718         uint32_t _ptr_driver_name;
11719         TALLOC_CTX *_mem_save_driver_name_0;
11720         uint32_t _ptr_architecture;
11721         TALLOC_CTX *_mem_save_architecture_0;
11722         uint32_t _ptr_driver_path;
11723         TALLOC_CTX *_mem_save_driver_path_0;
11724         uint32_t _ptr_data_file;
11725         TALLOC_CTX *_mem_save_data_file_0;
11726         uint32_t _ptr_config_file;
11727         TALLOC_CTX *_mem_save_config_file_0;
11728         uint32_t _ptr_help_file;
11729         TALLOC_CTX *_mem_save_help_file_0;
11730         uint32_t _ptr_dependent_files;
11731         TALLOC_CTX *_mem_save_dependent_files_0;
11732         uint32_t _ptr_monitor_name;
11733         TALLOC_CTX *_mem_save_monitor_name_0;
11734         uint32_t _ptr_default_datatype;
11735         TALLOC_CTX *_mem_save_default_datatype_0;
11736         uint32_t _ptr_previous_names;
11737         TALLOC_CTX *_mem_save_previous_names_0;
11738         uint32_t _ptr_manufacturer_name;
11739         TALLOC_CTX *_mem_save_manufacturer_name_0;
11740         uint32_t _ptr_manufacturer_url;
11741         TALLOC_CTX *_mem_save_manufacturer_url_0;
11742         uint32_t _ptr_hardware_id;
11743         TALLOC_CTX *_mem_save_hardware_id_0;
11744         uint32_t _ptr_provider;
11745         TALLOC_CTX *_mem_save_provider_0;
11746         if (ndr_flags & NDR_SCALARS) {
11747                 NDR_CHECK(ndr_pull_align(ndr, 8));
11748                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11749                 {
11750                         uint32_t _flags_save_string = ndr->flags;
11751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11752                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11753                         if (_ptr_driver_name) {
11754                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11755                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11756                         } else {
11757                                 r->driver_name = NULL;
11758                         }
11759                         ndr->flags = _flags_save_string;
11760                 }
11761                 {
11762                         uint32_t _flags_save_string = ndr->flags;
11763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11764                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11765                         if (_ptr_architecture) {
11766                                 NDR_PULL_ALLOC(ndr, r->architecture);
11767                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11768                         } else {
11769                                 r->architecture = NULL;
11770                         }
11771                         ndr->flags = _flags_save_string;
11772                 }
11773                 {
11774                         uint32_t _flags_save_string = ndr->flags;
11775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11777                         if (_ptr_driver_path) {
11778                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11780                         } else {
11781                                 r->driver_path = NULL;
11782                         }
11783                         ndr->flags = _flags_save_string;
11784                 }
11785                 {
11786                         uint32_t _flags_save_string = ndr->flags;
11787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11788                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11789                         if (_ptr_data_file) {
11790                                 NDR_PULL_ALLOC(ndr, r->data_file);
11791                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11792                         } else {
11793                                 r->data_file = NULL;
11794                         }
11795                         ndr->flags = _flags_save_string;
11796                 }
11797                 {
11798                         uint32_t _flags_save_string = ndr->flags;
11799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11801                         if (_ptr_config_file) {
11802                                 NDR_PULL_ALLOC(ndr, r->config_file);
11803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11804                         } else {
11805                                 r->config_file = NULL;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11813                         if (_ptr_help_file) {
11814                                 NDR_PULL_ALLOC(ndr, r->help_file);
11815                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11816                         } else {
11817                                 r->help_file = NULL;
11818                         }
11819                         ndr->flags = _flags_save_string;
11820                 }
11821                 {
11822                         uint32_t _flags_save_string_array = ndr->flags;
11823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11825                         if (_ptr_dependent_files) {
11826                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11828                         } else {
11829                                 r->dependent_files = NULL;
11830                         }
11831                         ndr->flags = _flags_save_string_array;
11832                 }
11833                 {
11834                         uint32_t _flags_save_string = ndr->flags;
11835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11837                         if (_ptr_monitor_name) {
11838                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11840                         } else {
11841                                 r->monitor_name = NULL;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11849                         if (_ptr_default_datatype) {
11850                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11852                         } else {
11853                                 r->default_datatype = NULL;
11854                         }
11855                         ndr->flags = _flags_save_string;
11856                 }
11857                 {
11858                         uint32_t _flags_save_string_array = ndr->flags;
11859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11861                         if (_ptr_previous_names) {
11862                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11864                         } else {
11865                                 r->previous_names = NULL;
11866                         }
11867                         ndr->flags = _flags_save_string_array;
11868                 }
11869                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11870                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11871                 {
11872                         uint32_t _flags_save_string = ndr->flags;
11873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11875                         if (_ptr_manufacturer_name) {
11876                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11878                         } else {
11879                                 r->manufacturer_name = NULL;
11880                         }
11881                         ndr->flags = _flags_save_string;
11882                 }
11883                 {
11884                         uint32_t _flags_save_string = ndr->flags;
11885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11887                         if (_ptr_manufacturer_url) {
11888                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11890                         } else {
11891                                 r->manufacturer_url = NULL;
11892                         }
11893                         ndr->flags = _flags_save_string;
11894                 }
11895                 {
11896                         uint32_t _flags_save_string = ndr->flags;
11897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11898                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11899                         if (_ptr_hardware_id) {
11900                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11902                         } else {
11903                                 r->hardware_id = NULL;
11904                         }
11905                         ndr->flags = _flags_save_string;
11906                 }
11907                 {
11908                         uint32_t _flags_save_string = ndr->flags;
11909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11911                         if (_ptr_provider) {
11912                                 NDR_PULL_ALLOC(ndr, r->provider);
11913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11914                         } else {
11915                                 r->provider = NULL;
11916                         }
11917                         ndr->flags = _flags_save_string;
11918                 }
11919         }
11920         if (ndr_flags & NDR_BUFFERS) {
11921                 {
11922                         uint32_t _flags_save_string = ndr->flags;
11923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11924                         if (r->driver_name) {
11925                                 uint32_t _relative_save_offset;
11926                                 _relative_save_offset = ndr->offset;
11927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11928                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11929                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
11940                                 uint32_t _relative_save_offset;
11941                                 _relative_save_offset = ndr->offset;
11942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11943                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11944                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
11955                                 uint32_t _relative_save_offset;
11956                                 _relative_save_offset = ndr->offset;
11957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11958                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11959                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11962                                 ndr->offset = _relative_save_offset;
11963                         }
11964                         ndr->flags = _flags_save_string;
11965                 }
11966                 {
11967                         uint32_t _flags_save_string = ndr->flags;
11968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11969                         if (r->data_file) {
11970                                 uint32_t _relative_save_offset;
11971                                 _relative_save_offset = ndr->offset;
11972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11973                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11974                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11975                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11977                                 ndr->offset = _relative_save_offset;
11978                         }
11979                         ndr->flags = _flags_save_string;
11980                 }
11981                 {
11982                         uint32_t _flags_save_string = ndr->flags;
11983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11984                         if (r->config_file) {
11985                                 uint32_t _relative_save_offset;
11986                                 _relative_save_offset = ndr->offset;
11987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11988                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11990                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_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->help_file) {
12000                                 uint32_t _relative_save_offset;
12001                                 _relative_save_offset = ndr->offset;
12002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12003                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12004                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_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->dependent_files) {
12015                                 uint32_t _relative_save_offset;
12016                                 _relative_save_offset = ndr->offset;
12017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12018                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12019                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12020                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_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->monitor_name) {
12030                                 uint32_t _relative_save_offset;
12031                                 _relative_save_offset = ndr->offset;
12032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12033                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12034                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_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->default_datatype) {
12045                                 uint32_t _relative_save_offset;
12046                                 _relative_save_offset = ndr->offset;
12047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12048                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12049                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12052                                 ndr->offset = _relative_save_offset;
12053                         }
12054                         ndr->flags = _flags_save_string;
12055                 }
12056                 {
12057                         uint32_t _flags_save_string_array = ndr->flags;
12058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12059                         if (r->previous_names) {
12060                                 uint32_t _relative_save_offset;
12061                                 _relative_save_offset = ndr->offset;
12062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12063                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12065                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12067                                 ndr->offset = _relative_save_offset;
12068                         }
12069                         ndr->flags = _flags_save_string_array;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         if (r->manufacturer_name) {
12075                                 uint32_t _relative_save_offset;
12076                                 _relative_save_offset = ndr->offset;
12077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12078                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12079                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12082                                 ndr->offset = _relative_save_offset;
12083                         }
12084                         ndr->flags = _flags_save_string;
12085                 }
12086                 {
12087                         uint32_t _flags_save_string = ndr->flags;
12088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12089                         if (r->manufacturer_url) {
12090                                 uint32_t _relative_save_offset;
12091                                 _relative_save_offset = ndr->offset;
12092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12093                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12094                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12095                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12097                                 ndr->offset = _relative_save_offset;
12098                         }
12099                         ndr->flags = _flags_save_string;
12100                 }
12101                 {
12102                         uint32_t _flags_save_string = ndr->flags;
12103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12104                         if (r->hardware_id) {
12105                                 uint32_t _relative_save_offset;
12106                                 _relative_save_offset = ndr->offset;
12107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12108                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12109                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12112                                 ndr->offset = _relative_save_offset;
12113                         }
12114                         ndr->flags = _flags_save_string;
12115                 }
12116                 {
12117                         uint32_t _flags_save_string = ndr->flags;
12118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12119                         if (r->provider) {
12120                                 uint32_t _relative_save_offset;
12121                                 _relative_save_offset = ndr->offset;
12122                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12123                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12124                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12125                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12126                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12127                                 ndr->offset = _relative_save_offset;
12128                         }
12129                         ndr->flags = _flags_save_string;
12130                 }
12131         }
12132         return NDR_ERR_SUCCESS;
12133 }
12134
12135 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12136 {
12137         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12138         ndr->depth++;
12139         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12140         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12141         ndr->depth++;
12142         if (r->driver_name) {
12143                 ndr_print_string(ndr, "driver_name", r->driver_name);
12144         }
12145         ndr->depth--;
12146         ndr_print_ptr(ndr, "architecture", r->architecture);
12147         ndr->depth++;
12148         if (r->architecture) {
12149                 ndr_print_string(ndr, "architecture", r->architecture);
12150         }
12151         ndr->depth--;
12152         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12153         ndr->depth++;
12154         if (r->driver_path) {
12155                 ndr_print_string(ndr, "driver_path", r->driver_path);
12156         }
12157         ndr->depth--;
12158         ndr_print_ptr(ndr, "data_file", r->data_file);
12159         ndr->depth++;
12160         if (r->data_file) {
12161                 ndr_print_string(ndr, "data_file", r->data_file);
12162         }
12163         ndr->depth--;
12164         ndr_print_ptr(ndr, "config_file", r->config_file);
12165         ndr->depth++;
12166         if (r->config_file) {
12167                 ndr_print_string(ndr, "config_file", r->config_file);
12168         }
12169         ndr->depth--;
12170         ndr_print_ptr(ndr, "help_file", r->help_file);
12171         ndr->depth++;
12172         if (r->help_file) {
12173                 ndr_print_string(ndr, "help_file", r->help_file);
12174         }
12175         ndr->depth--;
12176         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12177         ndr->depth++;
12178         if (r->dependent_files) {
12179                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12180         }
12181         ndr->depth--;
12182         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12183         ndr->depth++;
12184         if (r->monitor_name) {
12185                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12186         }
12187         ndr->depth--;
12188         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12189         ndr->depth++;
12190         if (r->default_datatype) {
12191                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12192         }
12193         ndr->depth--;
12194         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12195         ndr->depth++;
12196         if (r->previous_names) {
12197                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12198         }
12199         ndr->depth--;
12200         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12201         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12202         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12203         ndr->depth++;
12204         if (r->manufacturer_name) {
12205                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12206         }
12207         ndr->depth--;
12208         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12209         ndr->depth++;
12210         if (r->manufacturer_url) {
12211                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12212         }
12213         ndr->depth--;
12214         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12215         ndr->depth++;
12216         if (r->hardware_id) {
12217                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12218         }
12219         ndr->depth--;
12220         ndr_print_ptr(ndr, "provider", r->provider);
12221         ndr->depth++;
12222         if (r->provider) {
12223                 ndr_print_string(ndr, "provider", r->provider);
12224         }
12225         ndr->depth--;
12226         ndr->depth--;
12227 }
12228
12229 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12230 {
12231         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12232 }
12233
12234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12235 {
12236         if (ndr_flags & NDR_SCALARS) {
12237                 NDR_CHECK(ndr_push_align(ndr, 8));
12238                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12239                 {
12240                         uint32_t _flags_save_string = ndr->flags;
12241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12243                         ndr->flags = _flags_save_string;
12244                 }
12245                 {
12246                         uint32_t _flags_save_string = ndr->flags;
12247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12249                         ndr->flags = _flags_save_string;
12250                 }
12251                 {
12252                         uint32_t _flags_save_string = ndr->flags;
12253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12255                         ndr->flags = _flags_save_string;
12256                 }
12257                 {
12258                         uint32_t _flags_save_string = ndr->flags;
12259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12261                         ndr->flags = _flags_save_string;
12262                 }
12263                 {
12264                         uint32_t _flags_save_string = ndr->flags;
12265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12267                         ndr->flags = _flags_save_string;
12268                 }
12269                 {
12270                         uint32_t _flags_save_string = ndr->flags;
12271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12273                         ndr->flags = _flags_save_string;
12274                 }
12275                 {
12276                         uint32_t _flags_save_string = ndr->flags;
12277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12278                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12279                         ndr->flags = _flags_save_string;
12280                 }
12281                 {
12282                         uint32_t _flags_save_string = ndr->flags;
12283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12284                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12285                         ndr->flags = _flags_save_string;
12286                 }
12287                 {
12288                         uint32_t _flags_save_string_array = ndr->flags;
12289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12291                         ndr->flags = _flags_save_string_array;
12292                 }
12293                 {
12294                         uint32_t _flags_save_string_array = ndr->flags;
12295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12297                         ndr->flags = _flags_save_string_array;
12298                 }
12299                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12300                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12301                 {
12302                         uint32_t _flags_save_string = ndr->flags;
12303                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12304                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12305                         ndr->flags = _flags_save_string;
12306                 }
12307                 {
12308                         uint32_t _flags_save_string = ndr->flags;
12309                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12310                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12311                         ndr->flags = _flags_save_string;
12312                 }
12313                 {
12314                         uint32_t _flags_save_string = ndr->flags;
12315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12316                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12317                         ndr->flags = _flags_save_string;
12318                 }
12319                 {
12320                         uint32_t _flags_save_string = ndr->flags;
12321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12322                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12323                         ndr->flags = _flags_save_string;
12324                 }
12325                 {
12326                         uint32_t _flags_save_string = ndr->flags;
12327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12328                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12329                         ndr->flags = _flags_save_string;
12330                 }
12331                 {
12332                         uint32_t _flags_save_string = ndr->flags;
12333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12334                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12335                         ndr->flags = _flags_save_string;
12336                 }
12337                 {
12338                         uint32_t _flags_save_string_array = ndr->flags;
12339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12340                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12341                         ndr->flags = _flags_save_string_array;
12342                 }
12343                 {
12344                         uint32_t _flags_save_string = ndr->flags;
12345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12346                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12347                         ndr->flags = _flags_save_string;
12348                 }
12349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12350                 {
12351                         uint32_t _flags_save_string_array = ndr->flags;
12352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12353                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12354                         ndr->flags = _flags_save_string_array;
12355                 }
12356                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12357                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12358         }
12359         if (ndr_flags & NDR_BUFFERS) {
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         if (r->driver_name) {
12364                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12365                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
12373                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12374                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
12382                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12384                         }
12385                         ndr->flags = _flags_save_string;
12386                 }
12387                 {
12388                         uint32_t _flags_save_string = ndr->flags;
12389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12390                         if (r->data_file) {
12391                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12392                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12393                         }
12394                         ndr->flags = _flags_save_string;
12395                 }
12396                 {
12397                         uint32_t _flags_save_string = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         if (r->config_file) {
12400                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12401                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12402                         }
12403                         ndr->flags = _flags_save_string;
12404                 }
12405                 {
12406                         uint32_t _flags_save_string = ndr->flags;
12407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12408                         if (r->help_file) {
12409                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12410                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
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->monitor_name) {
12418                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12419                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->default_datatype) {
12427                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12428                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12429                         }
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string_array = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         if (r->dependent_files) {
12436                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12437                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12438                         }
12439                         ndr->flags = _flags_save_string_array;
12440                 }
12441                 {
12442                         uint32_t _flags_save_string_array = ndr->flags;
12443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12444                         if (r->previous_names) {
12445                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12446                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12447                         }
12448                         ndr->flags = _flags_save_string_array;
12449                 }
12450                 {
12451                         uint32_t _flags_save_string = ndr->flags;
12452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12453                         if (r->manufacturer_name) {
12454                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12455                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12456                         }
12457                         ndr->flags = _flags_save_string;
12458                 }
12459                 {
12460                         uint32_t _flags_save_string = ndr->flags;
12461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12462                         if (r->manufacturer_url) {
12463                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12464                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12465                         }
12466                         ndr->flags = _flags_save_string;
12467                 }
12468                 {
12469                         uint32_t _flags_save_string = ndr->flags;
12470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12471                         if (r->hardware_id) {
12472                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12473                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12474                         }
12475                         ndr->flags = _flags_save_string;
12476                 }
12477                 {
12478                         uint32_t _flags_save_string = ndr->flags;
12479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12480                         if (r->provider) {
12481                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12482                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12483                         }
12484                         ndr->flags = _flags_save_string;
12485                 }
12486                 {
12487                         uint32_t _flags_save_string = ndr->flags;
12488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12489                         if (r->print_processor) {
12490                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12491                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12492                         }
12493                         ndr->flags = _flags_save_string;
12494                 }
12495                 {
12496                         uint32_t _flags_save_string = ndr->flags;
12497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12498                         if (r->vendor_setup) {
12499                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12500                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12501                         }
12502                         ndr->flags = _flags_save_string;
12503                 }
12504                 {
12505                         uint32_t _flags_save_string_array = ndr->flags;
12506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12507                         if (r->color_profiles) {
12508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12509                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12510                         }
12511                         ndr->flags = _flags_save_string_array;
12512                 }
12513                 {
12514                         uint32_t _flags_save_string = ndr->flags;
12515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12516                         if (r->inf_path) {
12517                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12518                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12519                         }
12520                         ndr->flags = _flags_save_string;
12521                 }
12522                 {
12523                         uint32_t _flags_save_string_array = ndr->flags;
12524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12525                         if (r->core_driver_dependencies) {
12526                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12527                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12528                         }
12529                         ndr->flags = _flags_save_string_array;
12530                 }
12531         }
12532         return NDR_ERR_SUCCESS;
12533 }
12534
12535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12536 {
12537         uint32_t _ptr_driver_name;
12538         TALLOC_CTX *_mem_save_driver_name_0;
12539         uint32_t _ptr_architecture;
12540         TALLOC_CTX *_mem_save_architecture_0;
12541         uint32_t _ptr_driver_path;
12542         TALLOC_CTX *_mem_save_driver_path_0;
12543         uint32_t _ptr_data_file;
12544         TALLOC_CTX *_mem_save_data_file_0;
12545         uint32_t _ptr_config_file;
12546         TALLOC_CTX *_mem_save_config_file_0;
12547         uint32_t _ptr_help_file;
12548         TALLOC_CTX *_mem_save_help_file_0;
12549         uint32_t _ptr_monitor_name;
12550         TALLOC_CTX *_mem_save_monitor_name_0;
12551         uint32_t _ptr_default_datatype;
12552         TALLOC_CTX *_mem_save_default_datatype_0;
12553         uint32_t _ptr_dependent_files;
12554         TALLOC_CTX *_mem_save_dependent_files_0;
12555         uint32_t _ptr_previous_names;
12556         TALLOC_CTX *_mem_save_previous_names_0;
12557         uint32_t _ptr_manufacturer_name;
12558         TALLOC_CTX *_mem_save_manufacturer_name_0;
12559         uint32_t _ptr_manufacturer_url;
12560         TALLOC_CTX *_mem_save_manufacturer_url_0;
12561         uint32_t _ptr_hardware_id;
12562         TALLOC_CTX *_mem_save_hardware_id_0;
12563         uint32_t _ptr_provider;
12564         TALLOC_CTX *_mem_save_provider_0;
12565         uint32_t _ptr_print_processor;
12566         TALLOC_CTX *_mem_save_print_processor_0;
12567         uint32_t _ptr_vendor_setup;
12568         TALLOC_CTX *_mem_save_vendor_setup_0;
12569         uint32_t _ptr_color_profiles;
12570         TALLOC_CTX *_mem_save_color_profiles_0;
12571         uint32_t _ptr_inf_path;
12572         TALLOC_CTX *_mem_save_inf_path_0;
12573         uint32_t _ptr_core_driver_dependencies;
12574         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12575         if (ndr_flags & NDR_SCALARS) {
12576                 NDR_CHECK(ndr_pull_align(ndr, 8));
12577                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12578                 {
12579                         uint32_t _flags_save_string = ndr->flags;
12580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12581                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12582                         if (_ptr_driver_name) {
12583                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12584                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12585                         } else {
12586                                 r->driver_name = NULL;
12587                         }
12588                         ndr->flags = _flags_save_string;
12589                 }
12590                 {
12591                         uint32_t _flags_save_string = ndr->flags;
12592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12593                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12594                         if (_ptr_architecture) {
12595                                 NDR_PULL_ALLOC(ndr, r->architecture);
12596                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12597                         } else {
12598                                 r->architecture = NULL;
12599                         }
12600                         ndr->flags = _flags_save_string;
12601                 }
12602                 {
12603                         uint32_t _flags_save_string = ndr->flags;
12604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12605                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12606                         if (_ptr_driver_path) {
12607                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12608                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12609                         } else {
12610                                 r->driver_path = NULL;
12611                         }
12612                         ndr->flags = _flags_save_string;
12613                 }
12614                 {
12615                         uint32_t _flags_save_string = ndr->flags;
12616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12617                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12618                         if (_ptr_data_file) {
12619                                 NDR_PULL_ALLOC(ndr, r->data_file);
12620                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12621                         } else {
12622                                 r->data_file = NULL;
12623                         }
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12630                         if (_ptr_config_file) {
12631                                 NDR_PULL_ALLOC(ndr, r->config_file);
12632                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12633                         } else {
12634                                 r->config_file = NULL;
12635                         }
12636                         ndr->flags = _flags_save_string;
12637                 }
12638                 {
12639                         uint32_t _flags_save_string = ndr->flags;
12640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12641                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12642                         if (_ptr_help_file) {
12643                                 NDR_PULL_ALLOC(ndr, r->help_file);
12644                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12645                         } else {
12646                                 r->help_file = NULL;
12647                         }
12648                         ndr->flags = _flags_save_string;
12649                 }
12650                 {
12651                         uint32_t _flags_save_string = ndr->flags;
12652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12653                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12654                         if (_ptr_monitor_name) {
12655                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12656                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12657                         } else {
12658                                 r->monitor_name = NULL;
12659                         }
12660                         ndr->flags = _flags_save_string;
12661                 }
12662                 {
12663                         uint32_t _flags_save_string = ndr->flags;
12664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12665                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12666                         if (_ptr_default_datatype) {
12667                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12668                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12669                         } else {
12670                                 r->default_datatype = NULL;
12671                         }
12672                         ndr->flags = _flags_save_string;
12673                 }
12674                 {
12675                         uint32_t _flags_save_string_array = ndr->flags;
12676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12678                         if (_ptr_dependent_files) {
12679                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12680                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12681                         } else {
12682                                 r->dependent_files = NULL;
12683                         }
12684                         ndr->flags = _flags_save_string_array;
12685                 }
12686                 {
12687                         uint32_t _flags_save_string_array = ndr->flags;
12688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12689                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12690                         if (_ptr_previous_names) {
12691                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12692                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12693                         } else {
12694                                 r->previous_names = NULL;
12695                         }
12696                         ndr->flags = _flags_save_string_array;
12697                 }
12698                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12699                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12700                 {
12701                         uint32_t _flags_save_string = ndr->flags;
12702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12703                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12704                         if (_ptr_manufacturer_name) {
12705                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12706                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12707                         } else {
12708                                 r->manufacturer_name = NULL;
12709                         }
12710                         ndr->flags = _flags_save_string;
12711                 }
12712                 {
12713                         uint32_t _flags_save_string = ndr->flags;
12714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12715                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12716                         if (_ptr_manufacturer_url) {
12717                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12718                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12719                         } else {
12720                                 r->manufacturer_url = NULL;
12721                         }
12722                         ndr->flags = _flags_save_string;
12723                 }
12724                 {
12725                         uint32_t _flags_save_string = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12728                         if (_ptr_hardware_id) {
12729                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12731                         } else {
12732                                 r->hardware_id = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string;
12735                 }
12736                 {
12737                         uint32_t _flags_save_string = ndr->flags;
12738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12740                         if (_ptr_provider) {
12741                                 NDR_PULL_ALLOC(ndr, r->provider);
12742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12743                         } else {
12744                                 r->provider = NULL;
12745                         }
12746                         ndr->flags = _flags_save_string;
12747                 }
12748                 {
12749                         uint32_t _flags_save_string = ndr->flags;
12750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12752                         if (_ptr_print_processor) {
12753                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12755                         } else {
12756                                 r->print_processor = NULL;
12757                         }
12758                         ndr->flags = _flags_save_string;
12759                 }
12760                 {
12761                         uint32_t _flags_save_string = ndr->flags;
12762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12764                         if (_ptr_vendor_setup) {
12765                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12767                         } else {
12768                                 r->vendor_setup = NULL;
12769                         }
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string_array = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12776                         if (_ptr_color_profiles) {
12777                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12779                         } else {
12780                                 r->color_profiles = NULL;
12781                         }
12782                         ndr->flags = _flags_save_string_array;
12783                 }
12784                 {
12785                         uint32_t _flags_save_string = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12788                         if (_ptr_inf_path) {
12789                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12791                         } else {
12792                                 r->inf_path = NULL;
12793                         }
12794                         ndr->flags = _flags_save_string;
12795                 }
12796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12797                 {
12798                         uint32_t _flags_save_string_array = ndr->flags;
12799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12801                         if (_ptr_core_driver_dependencies) {
12802                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12804                         } else {
12805                                 r->core_driver_dependencies = NULL;
12806                         }
12807                         ndr->flags = _flags_save_string_array;
12808                 }
12809                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12810                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12811         }
12812         if (ndr_flags & NDR_BUFFERS) {
12813                 {
12814                         uint32_t _flags_save_string = ndr->flags;
12815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12816                         if (r->driver_name) {
12817                                 uint32_t _relative_save_offset;
12818                                 _relative_save_offset = ndr->offset;
12819                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12820                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12821                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12822                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12823                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_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->architecture) {
12832                                 uint32_t _relative_save_offset;
12833                                 _relative_save_offset = ndr->offset;
12834                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12835                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12836                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12837                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12838                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_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->driver_path) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12850                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_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->data_file) {
12862                                 uint32_t _relative_save_offset;
12863                                 _relative_save_offset = ndr->offset;
12864                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12865                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12866                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12867                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12868                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_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->config_file) {
12877                                 uint32_t _relative_save_offset;
12878                                 _relative_save_offset = ndr->offset;
12879                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12880                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12881                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12882                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12883                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12884                                 ndr->offset = _relative_save_offset;
12885                         }
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         if (r->help_file) {
12892                                 uint32_t _relative_save_offset;
12893                                 _relative_save_offset = ndr->offset;
12894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12895                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12896                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12897                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12899                                 ndr->offset = _relative_save_offset;
12900                         }
12901                         ndr->flags = _flags_save_string;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->monitor_name) {
12907                                 uint32_t _relative_save_offset;
12908                                 _relative_save_offset = ndr->offset;
12909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12910                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12912                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12914                                 ndr->offset = _relative_save_offset;
12915                         }
12916                         ndr->flags = _flags_save_string;
12917                 }
12918                 {
12919                         uint32_t _flags_save_string = ndr->flags;
12920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12921                         if (r->default_datatype) {
12922                                 uint32_t _relative_save_offset;
12923                                 _relative_save_offset = ndr->offset;
12924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12925                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12926                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string_array = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->dependent_files) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12940                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12942                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12944                                 ndr->offset = _relative_save_offset;
12945                         }
12946                         ndr->flags = _flags_save_string_array;
12947                 }
12948                 {
12949                         uint32_t _flags_save_string_array = ndr->flags;
12950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12951                         if (r->previous_names) {
12952                                 uint32_t _relative_save_offset;
12953                                 _relative_save_offset = ndr->offset;
12954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12955                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12956                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12957                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12959                                 ndr->offset = _relative_save_offset;
12960                         }
12961                         ndr->flags = _flags_save_string_array;
12962                 }
12963                 {
12964                         uint32_t _flags_save_string = ndr->flags;
12965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12966                         if (r->manufacturer_name) {
12967                                 uint32_t _relative_save_offset;
12968                                 _relative_save_offset = ndr->offset;
12969                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12970                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12971                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12972                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12973                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_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->manufacturer_url) {
12982                                 uint32_t _relative_save_offset;
12983                                 _relative_save_offset = ndr->offset;
12984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12985                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12986                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_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->hardware_id) {
12997                                 uint32_t _relative_save_offset;
12998                                 _relative_save_offset = ndr->offset;
12999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13000                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13004                                 ndr->offset = _relative_save_offset;
13005                         }
13006                         ndr->flags = _flags_save_string;
13007                 }
13008                 {
13009                         uint32_t _flags_save_string = ndr->flags;
13010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13011                         if (r->provider) {
13012                                 uint32_t _relative_save_offset;
13013                                 _relative_save_offset = ndr->offset;
13014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13015                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13016                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13017                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->print_processor) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13030                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13034                                 ndr->offset = _relative_save_offset;
13035                         }
13036                         ndr->flags = _flags_save_string;
13037                 }
13038                 {
13039                         uint32_t _flags_save_string = ndr->flags;
13040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13041                         if (r->vendor_setup) {
13042                                 uint32_t _relative_save_offset;
13043                                 _relative_save_offset = ndr->offset;
13044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13045                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13046                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13049                                 ndr->offset = _relative_save_offset;
13050                         }
13051                         ndr->flags = _flags_save_string;
13052                 }
13053                 {
13054                         uint32_t _flags_save_string_array = ndr->flags;
13055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13056                         if (r->color_profiles) {
13057                                 uint32_t _relative_save_offset;
13058                                 _relative_save_offset = ndr->offset;
13059                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13060                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13061                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13062                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13063                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13064                                 ndr->offset = _relative_save_offset;
13065                         }
13066                         ndr->flags = _flags_save_string_array;
13067                 }
13068                 {
13069                         uint32_t _flags_save_string = ndr->flags;
13070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13071                         if (r->inf_path) {
13072                                 uint32_t _relative_save_offset;
13073                                 _relative_save_offset = ndr->offset;
13074                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13075                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13076                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13077                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13078                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13079                                 ndr->offset = _relative_save_offset;
13080                         }
13081                         ndr->flags = _flags_save_string;
13082                 }
13083                 {
13084                         uint32_t _flags_save_string_array = ndr->flags;
13085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13086                         if (r->core_driver_dependencies) {
13087                                 uint32_t _relative_save_offset;
13088                                 _relative_save_offset = ndr->offset;
13089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13090                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13091                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13092                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13094                                 ndr->offset = _relative_save_offset;
13095                         }
13096                         ndr->flags = _flags_save_string_array;
13097                 }
13098         }
13099         return NDR_ERR_SUCCESS;
13100 }
13101
13102 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13103 {
13104         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13105         ndr->depth++;
13106         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13107         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13108         ndr->depth++;
13109         if (r->driver_name) {
13110                 ndr_print_string(ndr, "driver_name", r->driver_name);
13111         }
13112         ndr->depth--;
13113         ndr_print_ptr(ndr, "architecture", r->architecture);
13114         ndr->depth++;
13115         if (r->architecture) {
13116                 ndr_print_string(ndr, "architecture", r->architecture);
13117         }
13118         ndr->depth--;
13119         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13120         ndr->depth++;
13121         if (r->driver_path) {
13122                 ndr_print_string(ndr, "driver_path", r->driver_path);
13123         }
13124         ndr->depth--;
13125         ndr_print_ptr(ndr, "data_file", r->data_file);
13126         ndr->depth++;
13127         if (r->data_file) {
13128                 ndr_print_string(ndr, "data_file", r->data_file);
13129         }
13130         ndr->depth--;
13131         ndr_print_ptr(ndr, "config_file", r->config_file);
13132         ndr->depth++;
13133         if (r->config_file) {
13134                 ndr_print_string(ndr, "config_file", r->config_file);
13135         }
13136         ndr->depth--;
13137         ndr_print_ptr(ndr, "help_file", r->help_file);
13138         ndr->depth++;
13139         if (r->help_file) {
13140                 ndr_print_string(ndr, "help_file", r->help_file);
13141         }
13142         ndr->depth--;
13143         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13144         ndr->depth++;
13145         if (r->monitor_name) {
13146                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13147         }
13148         ndr->depth--;
13149         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13150         ndr->depth++;
13151         if (r->default_datatype) {
13152                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13153         }
13154         ndr->depth--;
13155         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13156         ndr->depth++;
13157         if (r->dependent_files) {
13158                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13159         }
13160         ndr->depth--;
13161         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13162         ndr->depth++;
13163         if (r->previous_names) {
13164                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13165         }
13166         ndr->depth--;
13167         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13168         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13169         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13170         ndr->depth++;
13171         if (r->manufacturer_name) {
13172                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13173         }
13174         ndr->depth--;
13175         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13176         ndr->depth++;
13177         if (r->manufacturer_url) {
13178                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13179         }
13180         ndr->depth--;
13181         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13182         ndr->depth++;
13183         if (r->hardware_id) {
13184                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13185         }
13186         ndr->depth--;
13187         ndr_print_ptr(ndr, "provider", r->provider);
13188         ndr->depth++;
13189         if (r->provider) {
13190                 ndr_print_string(ndr, "provider", r->provider);
13191         }
13192         ndr->depth--;
13193         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13194         ndr->depth++;
13195         if (r->print_processor) {
13196                 ndr_print_string(ndr, "print_processor", r->print_processor);
13197         }
13198         ndr->depth--;
13199         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13200         ndr->depth++;
13201         if (r->vendor_setup) {
13202                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13203         }
13204         ndr->depth--;
13205         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13206         ndr->depth++;
13207         if (r->color_profiles) {
13208                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13209         }
13210         ndr->depth--;
13211         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13212         ndr->depth++;
13213         if (r->inf_path) {
13214                 ndr_print_string(ndr, "inf_path", r->inf_path);
13215         }
13216         ndr->depth--;
13217         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13218         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13219         ndr->depth++;
13220         if (r->core_driver_dependencies) {
13221                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13222         }
13223         ndr->depth--;
13224         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13225         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13226         ndr->depth--;
13227 }
13228
13229 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13230 {
13231         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13232 }
13233
13234 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13235 {
13236         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13237         return NDR_ERR_SUCCESS;
13238 }
13239
13240 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13241 {
13242         uint32_t v;
13243         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13244         *r = v;
13245         return NDR_ERR_SUCCESS;
13246 }
13247
13248 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13249 {
13250         const char *val = NULL;
13251
13252         switch (r) {
13253                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13254                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13255                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13256                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13257                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13258         }
13259         ndr_print_enum(ndr, name, "ENUM", val, r);
13260 }
13261
13262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13263 {
13264         if (ndr_flags & NDR_SCALARS) {
13265                 NDR_CHECK(ndr_push_align(ndr, 4));
13266                 {
13267                         uint32_t _flags_save_string = ndr->flags;
13268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13270                         ndr->flags = _flags_save_string;
13271                 }
13272                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13274         }
13275         if (ndr_flags & NDR_BUFFERS) {
13276                 {
13277                         uint32_t _flags_save_string = ndr->flags;
13278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13279                         if (r->file_name) {
13280                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13281                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13282                         }
13283                         ndr->flags = _flags_save_string;
13284                 }
13285         }
13286         return NDR_ERR_SUCCESS;
13287 }
13288
13289 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13290 {
13291         uint32_t _ptr_file_name;
13292         TALLOC_CTX *_mem_save_file_name_0;
13293         if (ndr_flags & NDR_SCALARS) {
13294                 NDR_CHECK(ndr_pull_align(ndr, 4));
13295                 {
13296                         uint32_t _flags_save_string = ndr->flags;
13297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13298                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13299                         if (_ptr_file_name) {
13300                                 NDR_PULL_ALLOC(ndr, r->file_name);
13301                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13302                         } else {
13303                                 r->file_name = NULL;
13304                         }
13305                         ndr->flags = _flags_save_string;
13306                 }
13307                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13309         }
13310         if (ndr_flags & NDR_BUFFERS) {
13311                 {
13312                         uint32_t _flags_save_string = ndr->flags;
13313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13314                         if (r->file_name) {
13315                                 uint32_t _relative_save_offset;
13316                                 _relative_save_offset = ndr->offset;
13317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13318                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13319                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13322                                 ndr->offset = _relative_save_offset;
13323                         }
13324                         ndr->flags = _flags_save_string;
13325                 }
13326         }
13327         return NDR_ERR_SUCCESS;
13328 }
13329
13330 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13331 {
13332         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13333         ndr->depth++;
13334         ndr_print_ptr(ndr, "file_name", r->file_name);
13335         ndr->depth++;
13336         if (r->file_name) {
13337                 ndr_print_string(ndr, "file_name", r->file_name);
13338         }
13339         ndr->depth--;
13340         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13341         ndr_print_uint32(ndr, "file_version", r->file_version);
13342         ndr->depth--;
13343 }
13344
13345 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13346 {
13347         uint32_t cntr_file_info_1;
13348         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13349         ndr->depth++;
13350         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13351         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13352         ndr->depth++;
13353         if (r->driver_name) {
13354                 ndr_print_string(ndr, "driver_name", r->driver_name);
13355         }
13356         ndr->depth--;
13357         ndr_print_ptr(ndr, "architecture", r->architecture);
13358         ndr->depth++;
13359         if (r->architecture) {
13360                 ndr_print_string(ndr, "architecture", r->architecture);
13361         }
13362         ndr->depth--;
13363         ndr_print_ptr(ndr, "file_info", r->file_info);
13364         ndr->depth++;
13365         if (r->file_info) {
13366                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13367                 ndr->depth++;
13368                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13369                         char *idx_1=NULL;
13370                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13371                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13372                                 free(idx_1);
13373                         }
13374                 }
13375                 ndr->depth--;
13376         }
13377         ndr->depth--;
13378         ndr_print_uint32(ndr, "file_count", r->file_count);
13379         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13380         ndr->depth++;
13381         if (r->monitor_name) {
13382                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13383         }
13384         ndr->depth--;
13385         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13386         ndr->depth++;
13387         if (r->default_datatype) {
13388                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13389         }
13390         ndr->depth--;
13391         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13392         ndr->depth++;
13393         if (r->previous_names) {
13394                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13395         }
13396         ndr->depth--;
13397         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13398         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13399         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13400         ndr->depth++;
13401         if (r->manufacturer_name) {
13402                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13403         }
13404         ndr->depth--;
13405         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13406         ndr->depth++;
13407         if (r->manufacturer_url) {
13408                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13409         }
13410         ndr->depth--;
13411         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13412         ndr->depth++;
13413         if (r->hardware_id) {
13414                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13415         }
13416         ndr->depth--;
13417         ndr_print_ptr(ndr, "provider", r->provider);
13418         ndr->depth++;
13419         if (r->provider) {
13420                 ndr_print_string(ndr, "provider", r->provider);
13421         }
13422         ndr->depth--;
13423         ndr->depth--;
13424 }
13425
13426 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13427 {
13428         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13429 }
13430
13431 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13432 {
13433         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13434         if (ndr_flags & NDR_SCALARS) {
13435                 int level = ndr_push_get_switch_value(ndr, r);
13436                 switch (level) {
13437                         case 1: {
13438                                 NDR_CHECK(ndr_push_align(ndr, 4));
13439                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13440                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13441                         break; }
13442
13443                         case 2: {
13444                                 NDR_CHECK(ndr_push_align(ndr, 4));
13445                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13446                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13447                         break; }
13448
13449                         case 3: {
13450                                 NDR_CHECK(ndr_push_align(ndr, 4));
13451                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13452                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13453                         break; }
13454
13455                         case 4: {
13456                                 NDR_CHECK(ndr_push_align(ndr, 4));
13457                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13458                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13459                         break; }
13460
13461                         case 5: {
13462                                 NDR_CHECK(ndr_push_align(ndr, 4));
13463                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13464                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13465                         break; }
13466
13467                         case 6: {
13468                                 NDR_CHECK(ndr_push_align(ndr, 8));
13469                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13471                         break; }
13472
13473                         case 8: {
13474                                 NDR_CHECK(ndr_push_align(ndr, 8));
13475                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13476                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13477                         break; }
13478
13479                         case 101: {
13480                                 NDR_CHECK(ndr_push_align(ndr, 8));
13481                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13483                         break; }
13484
13485                         default: {
13486                         break; }
13487
13488                 }
13489         }
13490         if (ndr_flags & NDR_BUFFERS) {
13491                 int level = ndr_push_get_switch_value(ndr, r);
13492                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13493                 switch (level) {
13494                         case 1:
13495                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13496                         break;
13497
13498                         case 2:
13499                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13500                         break;
13501
13502                         case 3:
13503                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13504                         break;
13505
13506                         case 4:
13507                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13508                         break;
13509
13510                         case 5:
13511                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13512                         break;
13513
13514                         case 6:
13515                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13516                         break;
13517
13518                         case 8:
13519                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13520                         break;
13521
13522                         case 101:
13523                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13524                         break;
13525
13526                         default:
13527                         break;
13528
13529                 }
13530         }
13531         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13532         return NDR_ERR_SUCCESS;
13533 }
13534
13535 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13536 {
13537         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13538         int level;
13539         level = ndr_pull_get_switch_value(ndr, r);
13540         if (ndr_flags & NDR_SCALARS) {
13541                 switch (level) {
13542                         case 1: {
13543                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13544                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13545                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13546                         break; }
13547
13548                         case 2: {
13549                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13550                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13551                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13552                         break; }
13553
13554                         case 3: {
13555                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13556                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13557                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13558                         break; }
13559
13560                         case 4: {
13561                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13562                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13563                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13564                         break; }
13565
13566                         case 5: {
13567                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13568                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13569                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13570                         break; }
13571
13572                         case 6: {
13573                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13574                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13576                         break; }
13577
13578                         case 8: {
13579                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13580                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13581                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13582                         break; }
13583
13584                         case 101: {
13585                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13586                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13588                         break; }
13589
13590                         default: {
13591                         break; }
13592
13593                 }
13594         }
13595         if (ndr_flags & NDR_BUFFERS) {
13596                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13597                 switch (level) {
13598                         case 1:
13599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13600                         break;
13601
13602                         case 2:
13603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13604                         break;
13605
13606                         case 3:
13607                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13608                         break;
13609
13610                         case 4:
13611                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13612                         break;
13613
13614                         case 5:
13615                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13616                         break;
13617
13618                         case 6:
13619                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13620                         break;
13621
13622                         case 8:
13623                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13624                         break;
13625
13626                         case 101:
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13628                         break;
13629
13630                         default:
13631                         break;
13632
13633                 }
13634         }
13635         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13636         return NDR_ERR_SUCCESS;
13637 }
13638
13639 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13640 {
13641         int level;
13642         level = ndr_print_get_switch_value(ndr, r);
13643         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13644         switch (level) {
13645                 case 1:
13646                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13647                 break;
13648
13649                 case 2:
13650                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13651                 break;
13652
13653                 case 3:
13654                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13655                 break;
13656
13657                 case 4:
13658                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13659                 break;
13660
13661                 case 5:
13662                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13663                 break;
13664
13665                 case 6:
13666                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13667                 break;
13668
13669                 case 8:
13670                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13671                 break;
13672
13673                 case 101:
13674                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13675                 break;
13676
13677                 default:
13678                 break;
13679
13680         }
13681 }
13682
13683 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13684 {
13685         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13686 }
13687
13688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13689 {
13690         if (ndr_flags & NDR_SCALARS) {
13691                 NDR_CHECK(ndr_push_align(ndr, 4));
13692                 {
13693                         uint32_t _flags_save_string = ndr->flags;
13694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13695                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13696                         ndr->flags = _flags_save_string;
13697                 }
13698         }
13699         if (ndr_flags & NDR_BUFFERS) {
13700         }
13701         return NDR_ERR_SUCCESS;
13702 }
13703
13704 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13705 {
13706         if (ndr_flags & NDR_SCALARS) {
13707                 NDR_CHECK(ndr_pull_align(ndr, 4));
13708                 {
13709                         uint32_t _flags_save_string = ndr->flags;
13710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13711                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13712                         ndr->flags = _flags_save_string;
13713                 }
13714         }
13715         if (ndr_flags & NDR_BUFFERS) {
13716         }
13717         return NDR_ERR_SUCCESS;
13718 }
13719
13720 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13721 {
13722         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13723         ndr->depth++;
13724         ndr_print_string(ndr, "directory_name", r->directory_name);
13725         ndr->depth--;
13726 }
13727
13728 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13729 {
13730         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13731 }
13732
13733 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13734 {
13735         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13736         if (ndr_flags & NDR_SCALARS) {
13737                 int level = ndr_push_get_switch_value(ndr, r);
13738                 switch (level) {
13739                         case 1: {
13740                                 NDR_CHECK(ndr_push_align(ndr, 4));
13741                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13742                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13743                         break; }
13744
13745                         default: {
13746                                 NDR_CHECK(ndr_push_align(ndr, 4));
13747                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13748                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13749                         break; }
13750
13751                 }
13752         }
13753         if (ndr_flags & NDR_BUFFERS) {
13754                 int level = ndr_push_get_switch_value(ndr, r);
13755                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13756                 switch (level) {
13757                         case 1:
13758                         break;
13759
13760                         default:
13761                         break;
13762
13763                 }
13764         }
13765         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13766         return NDR_ERR_SUCCESS;
13767 }
13768
13769 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13770 {
13771         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13772         int level;
13773         level = ndr_pull_get_switch_value(ndr, r);
13774         if (ndr_flags & NDR_SCALARS) {
13775                 switch (level) {
13776                         case 1: {
13777                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13778                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13779                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13780                         break; }
13781
13782                         default: {
13783                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13784                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13785                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13786                         break; }
13787
13788                 }
13789         }
13790         if (ndr_flags & NDR_BUFFERS) {
13791                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13792                 switch (level) {
13793                         case 1:
13794                         break;
13795
13796                         default:
13797                         break;
13798
13799                 }
13800         }
13801         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13802         return NDR_ERR_SUCCESS;
13803 }
13804
13805 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13806 {
13807         int level;
13808         level = ndr_print_get_switch_value(ndr, r);
13809         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13810         switch (level) {
13811                 case 1:
13812                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13813                 break;
13814
13815                 default:
13816                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13817                 break;
13818
13819         }
13820 }
13821
13822 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13823 {
13824         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13825 }
13826
13827 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13828 {
13829         if (ndr_flags & NDR_SCALARS) {
13830                 NDR_CHECK(ndr_push_align(ndr, 4));
13831                 {
13832                         uint32_t _flags_save_string = ndr->flags;
13833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13834                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13835                         ndr->flags = _flags_save_string;
13836                 }
13837         }
13838         if (ndr_flags & NDR_BUFFERS) {
13839                 {
13840                         uint32_t _flags_save_string = ndr->flags;
13841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13842                         if (r->print_processor_name) {
13843                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13844                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13845                         }
13846                         ndr->flags = _flags_save_string;
13847                 }
13848         }
13849         return NDR_ERR_SUCCESS;
13850 }
13851
13852 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13853 {
13854         uint32_t _ptr_print_processor_name;
13855         TALLOC_CTX *_mem_save_print_processor_name_0;
13856         if (ndr_flags & NDR_SCALARS) {
13857                 NDR_CHECK(ndr_pull_align(ndr, 4));
13858                 {
13859                         uint32_t _flags_save_string = ndr->flags;
13860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13861                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13862                         if (_ptr_print_processor_name) {
13863                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13864                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13865                         } else {
13866                                 r->print_processor_name = NULL;
13867                         }
13868                         ndr->flags = _flags_save_string;
13869                 }
13870         }
13871         if (ndr_flags & NDR_BUFFERS) {
13872                 {
13873                         uint32_t _flags_save_string = ndr->flags;
13874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13875                         if (r->print_processor_name) {
13876                                 uint32_t _relative_save_offset;
13877                                 _relative_save_offset = ndr->offset;
13878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13879                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13880                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13883                                 ndr->offset = _relative_save_offset;
13884                         }
13885                         ndr->flags = _flags_save_string;
13886                 }
13887         }
13888         return NDR_ERR_SUCCESS;
13889 }
13890
13891 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13892 {
13893         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13894         ndr->depth++;
13895         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13896         ndr->depth++;
13897         if (r->print_processor_name) {
13898                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13899         }
13900         ndr->depth--;
13901         ndr->depth--;
13902 }
13903
13904 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13905 {
13906         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13907 }
13908
13909 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13910 {
13911         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13912         if (ndr_flags & NDR_SCALARS) {
13913                 int level = ndr_push_get_switch_value(ndr, r);
13914                 switch (level) {
13915                         case 1: {
13916                                 NDR_CHECK(ndr_push_align(ndr, 4));
13917                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13918                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13919                         break; }
13920
13921                         default: {
13922                         break; }
13923
13924                 }
13925         }
13926         if (ndr_flags & NDR_BUFFERS) {
13927                 int level = ndr_push_get_switch_value(ndr, r);
13928                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13929                 switch (level) {
13930                         case 1:
13931                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13932                         break;
13933
13934                         default:
13935                         break;
13936
13937                 }
13938         }
13939         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13940         return NDR_ERR_SUCCESS;
13941 }
13942
13943 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13944 {
13945         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13946         int level;
13947         level = ndr_pull_get_switch_value(ndr, r);
13948         if (ndr_flags & NDR_SCALARS) {
13949                 switch (level) {
13950                         case 1: {
13951                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13952                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13953                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13954                         break; }
13955
13956                         default: {
13957                         break; }
13958
13959                 }
13960         }
13961         if (ndr_flags & NDR_BUFFERS) {
13962                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13963                 switch (level) {
13964                         case 1:
13965                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13966                         break;
13967
13968                         default:
13969                         break;
13970
13971                 }
13972         }
13973         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13974         return NDR_ERR_SUCCESS;
13975 }
13976
13977 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13978 {
13979         int level;
13980         level = ndr_print_get_switch_value(ndr, r);
13981         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13982         switch (level) {
13983                 case 1:
13984                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13985                 break;
13986
13987                 default:
13988                 break;
13989
13990         }
13991 }
13992
13993 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13994 {
13995         if (ndr_flags & NDR_SCALARS) {
13996                 NDR_CHECK(ndr_push_align(ndr, 4));
13997                 {
13998                         uint32_t _flags_save_string = ndr->flags;
13999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14000                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14001                         ndr->flags = _flags_save_string;
14002                 }
14003         }
14004         if (ndr_flags & NDR_BUFFERS) {
14005         }
14006         return NDR_ERR_SUCCESS;
14007 }
14008
14009 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14010 {
14011         if (ndr_flags & NDR_SCALARS) {
14012                 NDR_CHECK(ndr_pull_align(ndr, 4));
14013                 {
14014                         uint32_t _flags_save_string = ndr->flags;
14015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14016                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14017                         ndr->flags = _flags_save_string;
14018                 }
14019         }
14020         if (ndr_flags & NDR_BUFFERS) {
14021         }
14022         return NDR_ERR_SUCCESS;
14023 }
14024
14025 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14026 {
14027         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14028         ndr->depth++;
14029         ndr_print_string(ndr, "directory_name", r->directory_name);
14030         ndr->depth--;
14031 }
14032
14033 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14034 {
14035         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14036 }
14037
14038 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14039 {
14040         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14041         if (ndr_flags & NDR_SCALARS) {
14042                 int level = ndr_push_get_switch_value(ndr, r);
14043                 switch (level) {
14044                         case 1: {
14045                                 NDR_CHECK(ndr_push_align(ndr, 4));
14046                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14047                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14048                         break; }
14049
14050                         default: {
14051                                 NDR_CHECK(ndr_push_align(ndr, 4));
14052                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14053                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14054                         break; }
14055
14056                 }
14057         }
14058         if (ndr_flags & NDR_BUFFERS) {
14059                 int level = ndr_push_get_switch_value(ndr, r);
14060                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14061                 switch (level) {
14062                         case 1:
14063                         break;
14064
14065                         default:
14066                         break;
14067
14068                 }
14069         }
14070         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14071         return NDR_ERR_SUCCESS;
14072 }
14073
14074 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14075 {
14076         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14077         int level;
14078         level = ndr_pull_get_switch_value(ndr, r);
14079         if (ndr_flags & NDR_SCALARS) {
14080                 switch (level) {
14081                         case 1: {
14082                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14084                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14085                         break; }
14086
14087                         default: {
14088                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14090                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14091                         break; }
14092
14093                 }
14094         }
14095         if (ndr_flags & NDR_BUFFERS) {
14096                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14097                 switch (level) {
14098                         case 1:
14099                         break;
14100
14101                         default:
14102                         break;
14103
14104                 }
14105         }
14106         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14107         return NDR_ERR_SUCCESS;
14108 }
14109
14110 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14111 {
14112         int level;
14113         level = ndr_print_get_switch_value(ndr, r);
14114         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14115         switch (level) {
14116                 case 1:
14117                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14118                 break;
14119
14120                 default:
14121                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14122                 break;
14123
14124         }
14125 }
14126
14127 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14128 {
14129         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14130 }
14131
14132 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14133 {
14134         if (ndr_flags & NDR_SCALARS) {
14135                 NDR_CHECK(ndr_push_align(ndr, 4));
14136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14137                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14138                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14139         }
14140         if (ndr_flags & NDR_BUFFERS) {
14141                 if (r->document_name) {
14142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14146                 }
14147                 if (r->output_file) {
14148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14151                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14152                 }
14153                 if (r->datatype) {
14154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14157                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14158                 }
14159         }
14160         return NDR_ERR_SUCCESS;
14161 }
14162
14163 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14164 {
14165         uint32_t _ptr_document_name;
14166         TALLOC_CTX *_mem_save_document_name_0;
14167         uint32_t _ptr_output_file;
14168         TALLOC_CTX *_mem_save_output_file_0;
14169         uint32_t _ptr_datatype;
14170         TALLOC_CTX *_mem_save_datatype_0;
14171         if (ndr_flags & NDR_SCALARS) {
14172                 NDR_CHECK(ndr_pull_align(ndr, 4));
14173                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14174                 if (_ptr_document_name) {
14175                         NDR_PULL_ALLOC(ndr, r->document_name);
14176                 } else {
14177                         r->document_name = NULL;
14178                 }
14179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14180                 if (_ptr_output_file) {
14181                         NDR_PULL_ALLOC(ndr, r->output_file);
14182                 } else {
14183                         r->output_file = NULL;
14184                 }
14185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14186                 if (_ptr_datatype) {
14187                         NDR_PULL_ALLOC(ndr, r->datatype);
14188                 } else {
14189                         r->datatype = NULL;
14190                 }
14191         }
14192         if (ndr_flags & NDR_BUFFERS) {
14193                 if (r->document_name) {
14194                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14195                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14198                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14199                                 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));
14200                         }
14201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14204                 }
14205                 if (r->output_file) {
14206                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14207                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14210                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14211                                 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));
14212                         }
14213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14216                 }
14217                 if (r->datatype) {
14218                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14222                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14223                                 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));
14224                         }
14225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14228                 }
14229         }
14230         return NDR_ERR_SUCCESS;
14231 }
14232
14233 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14234 {
14235         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14236         ndr->depth++;
14237         ndr_print_ptr(ndr, "document_name", r->document_name);
14238         ndr->depth++;
14239         if (r->document_name) {
14240                 ndr_print_string(ndr, "document_name", r->document_name);
14241         }
14242         ndr->depth--;
14243         ndr_print_ptr(ndr, "output_file", r->output_file);
14244         ndr->depth++;
14245         if (r->output_file) {
14246                 ndr_print_string(ndr, "output_file", r->output_file);
14247         }
14248         ndr->depth--;
14249         ndr_print_ptr(ndr, "datatype", r->datatype);
14250         ndr->depth++;
14251         if (r->datatype) {
14252                 ndr_print_string(ndr, "datatype", r->datatype);
14253         }
14254         ndr->depth--;
14255         ndr->depth--;
14256 }
14257
14258 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14259 {
14260         if (ndr_flags & NDR_SCALARS) {
14261                 int level = ndr_push_get_switch_value(ndr, r);
14262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14263                 switch (level) {
14264                         case 1: {
14265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14266                         break; }
14267
14268                         case 2: {
14269                         break; }
14270
14271                         case 3: {
14272                         break; }
14273
14274                         default: {
14275                         break; }
14276
14277                 }
14278         }
14279         if (ndr_flags & NDR_BUFFERS) {
14280                 int level = ndr_push_get_switch_value(ndr, r);
14281                 switch (level) {
14282                         case 1:
14283                                 if (r->info1) {
14284                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14285                                 }
14286                         break;
14287
14288                         case 2:
14289                         break;
14290
14291                         case 3:
14292                         break;
14293
14294                         default:
14295                         break;
14296
14297                 }
14298         }
14299         return NDR_ERR_SUCCESS;
14300 }
14301
14302 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14303 {
14304         int level;
14305         uint32_t _level;
14306         TALLOC_CTX *_mem_save_info1_0;
14307         level = ndr_pull_get_switch_value(ndr, r);
14308         if (ndr_flags & NDR_SCALARS) {
14309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14310                 if (_level != level) {
14311                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14312                 }
14313                 switch (level) {
14314                         case 1: {
14315                                 uint32_t _ptr_info1;
14316                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14317                                 if (_ptr_info1) {
14318                                         NDR_PULL_ALLOC(ndr, r->info1);
14319                                 } else {
14320                                         r->info1 = NULL;
14321                                 }
14322                         break; }
14323
14324                         case 2: {
14325                         break; }
14326
14327                         case 3: {
14328                         break; }
14329
14330                         default: {
14331                         break; }
14332
14333                 }
14334         }
14335         if (ndr_flags & NDR_BUFFERS) {
14336                 switch (level) {
14337                         case 1:
14338                                 if (r->info1) {
14339                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14340                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14341                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14342                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14343                                 }
14344                         break;
14345
14346                         case 2:
14347                         break;
14348
14349                         case 3:
14350                         break;
14351
14352                         default:
14353                         break;
14354
14355                 }
14356         }
14357         return NDR_ERR_SUCCESS;
14358 }
14359
14360 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14361 {
14362         int level;
14363         level = ndr_print_get_switch_value(ndr, r);
14364         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14365         switch (level) {
14366                 case 1:
14367                         ndr_print_ptr(ndr, "info1", r->info1);
14368                         ndr->depth++;
14369                         if (r->info1) {
14370                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14371                         }
14372                         ndr->depth--;
14373                 break;
14374
14375                 case 2:
14376                 break;
14377
14378                 case 3:
14379                 break;
14380
14381                 default:
14382                 break;
14383
14384         }
14385 }
14386
14387 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14388 {
14389         if (ndr_flags & NDR_SCALARS) {
14390                 NDR_CHECK(ndr_push_align(ndr, 4));
14391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14396                 {
14397                         uint32_t _flags_save_string = ndr->flags;
14398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14399                         {
14400                                 struct ndr_push *_ndr_extra_string;
14401                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14402                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14403                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14404                         }
14405                         ndr->flags = _flags_save_string;
14406                 }
14407         }
14408         if (ndr_flags & NDR_BUFFERS) {
14409         }
14410         return NDR_ERR_SUCCESS;
14411 }
14412
14413 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14414 {
14415         if (ndr_flags & NDR_SCALARS) {
14416                 NDR_CHECK(ndr_pull_align(ndr, 4));
14417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14422                 {
14423                         uint32_t _flags_save_string = ndr->flags;
14424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14425                         {
14426                                 struct ndr_pull *_ndr_extra_string;
14427                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14428                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14429                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14430                         }
14431                         ndr->flags = _flags_save_string;
14432                 }
14433         }
14434         if (ndr_flags & NDR_BUFFERS) {
14435         }
14436         return NDR_ERR_SUCCESS;
14437 }
14438
14439 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14440 {
14441         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14442         ndr->depth++;
14443         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);
14444         ndr_print_uint32(ndr, "major", r->major);
14445         ndr_print_uint32(ndr, "minor", r->minor);
14446         ndr_print_uint32(ndr, "build", r->build);
14447         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14448         ndr_print_string(ndr, "extra_string", r->extra_string);
14449         ndr->depth--;
14450 }
14451
14452 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14453 {
14454         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14455 }
14456
14457 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14458 {
14459         if (ndr_flags & NDR_SCALARS) {
14460                 NDR_CHECK(ndr_push_align(ndr, 4));
14461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14466                 {
14467                         uint32_t _flags_save_string = ndr->flags;
14468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14469                         {
14470                                 struct ndr_push *_ndr_extra_string;
14471                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14472                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14473                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14474                         }
14475                         ndr->flags = _flags_save_string;
14476                 }
14477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14479         }
14480         if (ndr_flags & NDR_BUFFERS) {
14481         }
14482         return NDR_ERR_SUCCESS;
14483 }
14484
14485 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14486 {
14487         if (ndr_flags & NDR_SCALARS) {
14488                 NDR_CHECK(ndr_pull_align(ndr, 4));
14489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14494                 {
14495                         uint32_t _flags_save_string = ndr->flags;
14496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14497                         {
14498                                 struct ndr_pull *_ndr_extra_string;
14499                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14500                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14501                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14502                         }
14503                         ndr->flags = _flags_save_string;
14504                 }
14505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14507         }
14508         if (ndr_flags & NDR_BUFFERS) {
14509         }
14510         return NDR_ERR_SUCCESS;
14511 }
14512
14513 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14514 {
14515         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14516         ndr->depth++;
14517         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);
14518         ndr_print_uint32(ndr, "major", r->major);
14519         ndr_print_uint32(ndr, "minor", r->minor);
14520         ndr_print_uint32(ndr, "build", r->build);
14521         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14522         ndr_print_string(ndr, "extra_string", r->extra_string);
14523         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14524         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14525         ndr->depth--;
14526 }
14527
14528 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14529 {
14530         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14531 }
14532
14533 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14534 {
14535         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14536         return NDR_ERR_SUCCESS;
14537 }
14538
14539 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14540 {
14541         uint32_t v;
14542         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14543         *r = v;
14544         return NDR_ERR_SUCCESS;
14545 }
14546
14547 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14548 {
14549         const char *val = NULL;
14550
14551         switch (r) {
14552                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14553                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14554                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14555                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14556                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14557         }
14558         ndr_print_enum(ndr, name, "ENUM", val, r);
14559 }
14560
14561 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14562 {
14563         if (ndr_flags & NDR_SCALARS) {
14564                 int level = ndr_push_get_switch_value(ndr, r);
14565                 switch (level) {
14566                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14567                         break; }
14568
14569                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14570                                 {
14571                                         uint32_t _flags_save_string = ndr->flags;
14572                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14573                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14574                                         ndr->flags = _flags_save_string;
14575                                 }
14576                         break; }
14577
14578                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14579                                 {
14580                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14581                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14582                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14583                                         ndr->flags = _flags_save_DATA_BLOB;
14584                                 }
14585                         break; }
14586
14587                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14588                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14589                         break; }
14590
14591                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14592                                 {
14593                                         uint32_t _flags_save_string_array = ndr->flags;
14594                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14595                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14596                                         ndr->flags = _flags_save_string_array;
14597                                 }
14598                         break; }
14599
14600                         default: {
14601                                 {
14602                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14603                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14604                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14605                                         ndr->flags = _flags_save_DATA_BLOB;
14606                                 }
14607                         break; }
14608
14609                 }
14610         }
14611         if (ndr_flags & NDR_BUFFERS) {
14612                 int level = ndr_push_get_switch_value(ndr, r);
14613                 switch (level) {
14614                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14615                         break;
14616
14617                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14618                         break;
14619
14620                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14621                         break;
14622
14623                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14624                         break;
14625
14626                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14627                         break;
14628
14629                         default:
14630                         break;
14631
14632                 }
14633         }
14634         return NDR_ERR_SUCCESS;
14635 }
14636
14637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14638 {
14639         int level;
14640         level = ndr_pull_get_switch_value(ndr, r);
14641         if (ndr_flags & NDR_SCALARS) {
14642                 switch (level) {
14643                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14644                         break; }
14645
14646                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14647                                 {
14648                                         uint32_t _flags_save_string = ndr->flags;
14649                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14650                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14651                                         ndr->flags = _flags_save_string;
14652                                 }
14653                         break; }
14654
14655                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14656                                 {
14657                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14658                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14659                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14660                                         ndr->flags = _flags_save_DATA_BLOB;
14661                                 }
14662                         break; }
14663
14664                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14665                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14666                         break; }
14667
14668                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14669                                 {
14670                                         uint32_t _flags_save_string_array = ndr->flags;
14671                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14672                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14673                                         ndr->flags = _flags_save_string_array;
14674                                 }
14675                         break; }
14676
14677                         default: {
14678                                 {
14679                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14680                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14681                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14682                                         ndr->flags = _flags_save_DATA_BLOB;
14683                                 }
14684                         break; }
14685
14686                 }
14687         }
14688         if (ndr_flags & NDR_BUFFERS) {
14689                 switch (level) {
14690                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14691                         break;
14692
14693                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14694                         break;
14695
14696                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14697                         break;
14698
14699                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14700                         break;
14701
14702                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14703                         break;
14704
14705                         default:
14706                         break;
14707
14708                 }
14709         }
14710         return NDR_ERR_SUCCESS;
14711 }
14712
14713 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14714 {
14715         int level;
14716         level = ndr_print_get_switch_value(ndr, r);
14717         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14718         switch (level) {
14719                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14720                 break;
14721
14722                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14723                         ndr_print_string(ndr, "string", r->string);
14724                 break;
14725
14726                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14727                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14728                 break;
14729
14730                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14731                         ndr_print_uint32(ndr, "value", r->value);
14732                 break;
14733
14734                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14735                         ndr_print_string_array(ndr, "string_array", r->string_array);
14736                 break;
14737
14738                 default:
14739                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14740                 break;
14741
14742         }
14743 }
14744
14745 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14746 {
14747         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14748 }
14749
14750 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14751 {
14752         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14753         return NDR_ERR_SUCCESS;
14754 }
14755
14756 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14757 {
14758         uint32_t v;
14759         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14760         *r = v;
14761         return NDR_ERR_SUCCESS;
14762 }
14763
14764 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14765 {
14766         const char *val = NULL;
14767
14768         switch (r) {
14769                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14770                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14771                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14772         }
14773         ndr_print_enum(ndr, name, "ENUM", val, r);
14774 }
14775
14776 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14777 {
14778         if (ndr_flags & NDR_SCALARS) {
14779                 NDR_CHECK(ndr_push_align(ndr, 4));
14780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14782         }
14783         if (ndr_flags & NDR_BUFFERS) {
14784         }
14785         return NDR_ERR_SUCCESS;
14786 }
14787
14788 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14789 {
14790         if (ndr_flags & NDR_SCALARS) {
14791                 NDR_CHECK(ndr_pull_align(ndr, 4));
14792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14794         }
14795         if (ndr_flags & NDR_BUFFERS) {
14796         }
14797         return NDR_ERR_SUCCESS;
14798 }
14799
14800 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14801 {
14802         ndr_print_struct(ndr, name, "spoolss_FormSize");
14803         ndr->depth++;
14804         ndr_print_uint32(ndr, "width", r->width);
14805         ndr_print_uint32(ndr, "height", r->height);
14806         ndr->depth--;
14807 }
14808
14809 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14810 {
14811         if (ndr_flags & NDR_SCALARS) {
14812                 NDR_CHECK(ndr_push_align(ndr, 4));
14813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14817         }
14818         if (ndr_flags & NDR_BUFFERS) {
14819         }
14820         return NDR_ERR_SUCCESS;
14821 }
14822
14823 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14824 {
14825         if (ndr_flags & NDR_SCALARS) {
14826                 NDR_CHECK(ndr_pull_align(ndr, 4));
14827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14831         }
14832         if (ndr_flags & NDR_BUFFERS) {
14833         }
14834         return NDR_ERR_SUCCESS;
14835 }
14836
14837 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14838 {
14839         ndr_print_struct(ndr, name, "spoolss_FormArea");
14840         ndr->depth++;
14841         ndr_print_uint32(ndr, "left", r->left);
14842         ndr_print_uint32(ndr, "top", r->top);
14843         ndr_print_uint32(ndr, "right", r->right);
14844         ndr_print_uint32(ndr, "bottom", r->bottom);
14845         ndr->depth--;
14846 }
14847
14848 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14849 {
14850         if (ndr_flags & NDR_SCALARS) {
14851                 NDR_CHECK(ndr_push_align(ndr, 4));
14852                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14853                 {
14854                         uint32_t _flags_save_string = ndr->flags;
14855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14857                         ndr->flags = _flags_save_string;
14858                 }
14859                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14860                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14861         }
14862         if (ndr_flags & NDR_BUFFERS) {
14863                 {
14864                         uint32_t _flags_save_string = ndr->flags;
14865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14866                         if (r->form_name) {
14867                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14868                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14869                         }
14870                         ndr->flags = _flags_save_string;
14871                 }
14872         }
14873         return NDR_ERR_SUCCESS;
14874 }
14875
14876 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14877 {
14878         uint32_t _ptr_form_name;
14879         TALLOC_CTX *_mem_save_form_name_0;
14880         if (ndr_flags & NDR_SCALARS) {
14881                 NDR_CHECK(ndr_pull_align(ndr, 4));
14882                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14883                 {
14884                         uint32_t _flags_save_string = ndr->flags;
14885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14887                         if (_ptr_form_name) {
14888                                 NDR_PULL_ALLOC(ndr, r->form_name);
14889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14890                         } else {
14891                                 r->form_name = NULL;
14892                         }
14893                         ndr->flags = _flags_save_string;
14894                 }
14895                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14896                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14897         }
14898         if (ndr_flags & NDR_BUFFERS) {
14899                 {
14900                         uint32_t _flags_save_string = ndr->flags;
14901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14902                         if (r->form_name) {
14903                                 uint32_t _relative_save_offset;
14904                                 _relative_save_offset = ndr->offset;
14905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14906                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14907                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14908                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14910                                 ndr->offset = _relative_save_offset;
14911                         }
14912                         ndr->flags = _flags_save_string;
14913                 }
14914         }
14915         return NDR_ERR_SUCCESS;
14916 }
14917
14918 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14919 {
14920         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14921         ndr->depth++;
14922         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14923         ndr_print_ptr(ndr, "form_name", r->form_name);
14924         ndr->depth++;
14925         if (r->form_name) {
14926                 ndr_print_string(ndr, "form_name", r->form_name);
14927         }
14928         ndr->depth--;
14929         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14930         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14931         ndr->depth--;
14932 }
14933
14934 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14935 {
14936         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14937 }
14938
14939 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14940 {
14941         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14942         return NDR_ERR_SUCCESS;
14943 }
14944
14945 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14946 {
14947         uint32_t v;
14948         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14949         *r = v;
14950         return NDR_ERR_SUCCESS;
14951 }
14952
14953 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14954 {
14955         ndr_print_uint32(ndr, name, r);
14956         ndr->depth++;
14957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14960         ndr->depth--;
14961 }
14962
14963 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14964 {
14965         if (ndr_flags & NDR_SCALARS) {
14966                 NDR_CHECK(ndr_push_align(ndr, 4));
14967                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14968                 {
14969                         uint32_t _flags_save_string = ndr->flags;
14970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14971                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14972                         ndr->flags = _flags_save_string;
14973                 }
14974                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14975                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14976                 {
14977                         uint32_t _flags_save_string = ndr->flags;
14978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14979                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14980                         ndr->flags = _flags_save_string;
14981                 }
14982                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14983                 {
14984                         uint32_t _flags_save_string = ndr->flags;
14985                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14986                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14987                         ndr->flags = _flags_save_string;
14988                 }
14989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14990                 {
14991                         uint32_t _flags_save_string = ndr->flags;
14992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14994                         ndr->flags = _flags_save_string;
14995                 }
14996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14997         }
14998         if (ndr_flags & NDR_BUFFERS) {
14999                 {
15000                         uint32_t _flags_save_string = ndr->flags;
15001                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15002                         if (r->form_name) {
15003                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15004                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15005                         }
15006                         ndr->flags = _flags_save_string;
15007                 }
15008                 {
15009                         uint32_t _flags_save_string = ndr->flags;
15010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15011                         if (r->keyword) {
15012                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15013                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15014                         }
15015                         ndr->flags = _flags_save_string;
15016                 }
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         if (r->mui_dll) {
15021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15023                         }
15024                         ndr->flags = _flags_save_string;
15025                 }
15026                 {
15027                         uint32_t _flags_save_string = ndr->flags;
15028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15029                         if (r->display_name) {
15030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15032                         }
15033                         ndr->flags = _flags_save_string;
15034                 }
15035         }
15036         return NDR_ERR_SUCCESS;
15037 }
15038
15039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15040 {
15041         uint32_t _ptr_form_name;
15042         TALLOC_CTX *_mem_save_form_name_0;
15043         uint32_t _ptr_keyword;
15044         TALLOC_CTX *_mem_save_keyword_0;
15045         uint32_t _ptr_mui_dll;
15046         TALLOC_CTX *_mem_save_mui_dll_0;
15047         uint32_t _ptr_display_name;
15048         TALLOC_CTX *_mem_save_display_name_0;
15049         if (ndr_flags & NDR_SCALARS) {
15050                 NDR_CHECK(ndr_pull_align(ndr, 4));
15051                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15052                 {
15053                         uint32_t _flags_save_string = ndr->flags;
15054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15055                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15056                         if (_ptr_form_name) {
15057                                 NDR_PULL_ALLOC(ndr, r->form_name);
15058                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15059                         } else {
15060                                 r->form_name = NULL;
15061                         }
15062                         ndr->flags = _flags_save_string;
15063                 }
15064                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15065                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15066                 {
15067                         uint32_t _flags_save_string = ndr->flags;
15068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15069                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15070                         if (_ptr_keyword) {
15071                                 NDR_PULL_ALLOC(ndr, r->keyword);
15072                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15073                         } else {
15074                                 r->keyword = NULL;
15075                         }
15076                         ndr->flags = _flags_save_string;
15077                 }
15078                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15079                 {
15080                         uint32_t _flags_save_string = ndr->flags;
15081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15083                         if (_ptr_mui_dll) {
15084                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15086                         } else {
15087                                 r->mui_dll = NULL;
15088                         }
15089                         ndr->flags = _flags_save_string;
15090                 }
15091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15092                 {
15093                         uint32_t _flags_save_string = ndr->flags;
15094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15096                         if (_ptr_display_name) {
15097                                 NDR_PULL_ALLOC(ndr, r->display_name);
15098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15099                         } else {
15100                                 r->display_name = NULL;
15101                         }
15102                         ndr->flags = _flags_save_string;
15103                 }
15104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15105         }
15106         if (ndr_flags & NDR_BUFFERS) {
15107                 {
15108                         uint32_t _flags_save_string = ndr->flags;
15109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15110                         if (r->form_name) {
15111                                 uint32_t _relative_save_offset;
15112                                 _relative_save_offset = ndr->offset;
15113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15114                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15115                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15116                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15118                                 ndr->offset = _relative_save_offset;
15119                         }
15120                         ndr->flags = _flags_save_string;
15121                 }
15122                 {
15123                         uint32_t _flags_save_string = ndr->flags;
15124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15125                         if (r->keyword) {
15126                                 uint32_t _relative_save_offset;
15127                                 _relative_save_offset = ndr->offset;
15128                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15129                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15130                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15131                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15132                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15133                                 ndr->offset = _relative_save_offset;
15134                         }
15135                         ndr->flags = _flags_save_string;
15136                 }
15137                 {
15138                         uint32_t _flags_save_string = ndr->flags;
15139                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15140                         if (r->mui_dll) {
15141                                 uint32_t _relative_save_offset;
15142                                 _relative_save_offset = ndr->offset;
15143                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15144                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15145                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15146                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15147                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15148                                 ndr->offset = _relative_save_offset;
15149                         }
15150                         ndr->flags = _flags_save_string;
15151                 }
15152                 {
15153                         uint32_t _flags_save_string = ndr->flags;
15154                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15155                         if (r->display_name) {
15156                                 uint32_t _relative_save_offset;
15157                                 _relative_save_offset = ndr->offset;
15158                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15159                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15160                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15161                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15162                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15163                                 ndr->offset = _relative_save_offset;
15164                         }
15165                         ndr->flags = _flags_save_string;
15166                 }
15167         }
15168         return NDR_ERR_SUCCESS;
15169 }
15170
15171 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15172 {
15173         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15174         ndr->depth++;
15175         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15176         ndr_print_ptr(ndr, "form_name", r->form_name);
15177         ndr->depth++;
15178         if (r->form_name) {
15179                 ndr_print_string(ndr, "form_name", r->form_name);
15180         }
15181         ndr->depth--;
15182         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15183         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15184         ndr_print_ptr(ndr, "keyword", r->keyword);
15185         ndr->depth++;
15186         if (r->keyword) {
15187                 ndr_print_string(ndr, "keyword", r->keyword);
15188         }
15189         ndr->depth--;
15190         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15191         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15192         ndr->depth++;
15193         if (r->mui_dll) {
15194                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15195         }
15196         ndr->depth--;
15197         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15198         ndr_print_ptr(ndr, "display_name", r->display_name);
15199         ndr->depth++;
15200         if (r->display_name) {
15201                 ndr_print_string(ndr, "display_name", r->display_name);
15202         }
15203         ndr->depth--;
15204         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15205         ndr->depth--;
15206 }
15207
15208 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15209 {
15210         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15211 }
15212
15213 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15214 {
15215         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15216         if (ndr_flags & NDR_SCALARS) {
15217                 int level = ndr_push_get_switch_value(ndr, r);
15218                 switch (level) {
15219                         case 1: {
15220                                 NDR_CHECK(ndr_push_align(ndr, 4));
15221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15222                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15223                         break; }
15224
15225                         case 2: {
15226                                 NDR_CHECK(ndr_push_align(ndr, 4));
15227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15228                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15229                         break; }
15230
15231                         default: {
15232                         break; }
15233
15234                 }
15235         }
15236         if (ndr_flags & NDR_BUFFERS) {
15237                 int level = ndr_push_get_switch_value(ndr, r);
15238                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15239                 switch (level) {
15240                         case 1:
15241                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15242                         break;
15243
15244                         case 2:
15245                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15246                         break;
15247
15248                         default:
15249                         break;
15250
15251                 }
15252         }
15253         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15254         return NDR_ERR_SUCCESS;
15255 }
15256
15257 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15258 {
15259         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15260         int level;
15261         level = ndr_pull_get_switch_value(ndr, r);
15262         if (ndr_flags & NDR_SCALARS) {
15263                 switch (level) {
15264                         case 1: {
15265                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15266                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15267                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15268                         break; }
15269
15270                         case 2: {
15271                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15272                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15273                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15274                         break; }
15275
15276                         default: {
15277                         break; }
15278
15279                 }
15280         }
15281         if (ndr_flags & NDR_BUFFERS) {
15282                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15283                 switch (level) {
15284                         case 1:
15285                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15286                         break;
15287
15288                         case 2:
15289                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15290                         break;
15291
15292                         default:
15293                         break;
15294
15295                 }
15296         }
15297         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15298         return NDR_ERR_SUCCESS;
15299 }
15300
15301 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15302 {
15303         int level;
15304         level = ndr_print_get_switch_value(ndr, r);
15305         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15306         switch (level) {
15307                 case 1:
15308                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15309                 break;
15310
15311                 case 2:
15312                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15313                 break;
15314
15315                 default:
15316                 break;
15317
15318         }
15319 }
15320
15321 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15322 {
15323         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15324 }
15325
15326 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15327 {
15328         if (ndr_flags & NDR_SCALARS) {
15329                 NDR_CHECK(ndr_push_align(ndr, 4));
15330                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15332                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15333                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15334         }
15335         if (ndr_flags & NDR_BUFFERS) {
15336                 if (r->form_name) {
15337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15341                 }
15342         }
15343         return NDR_ERR_SUCCESS;
15344 }
15345
15346 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15347 {
15348         uint32_t _ptr_form_name;
15349         TALLOC_CTX *_mem_save_form_name_0;
15350         if (ndr_flags & NDR_SCALARS) {
15351                 NDR_CHECK(ndr_pull_align(ndr, 4));
15352                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15354                 if (_ptr_form_name) {
15355                         NDR_PULL_ALLOC(ndr, r->form_name);
15356                 } else {
15357                         r->form_name = NULL;
15358                 }
15359                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15360                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15361         }
15362         if (ndr_flags & NDR_BUFFERS) {
15363                 if (r->form_name) {
15364                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15365                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15366                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15367                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15368                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15369                                 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));
15370                         }
15371                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15372                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15374                 }
15375         }
15376         return NDR_ERR_SUCCESS;
15377 }
15378
15379 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15380 {
15381         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15382         ndr->depth++;
15383         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15384         ndr_print_ptr(ndr, "form_name", r->form_name);
15385         ndr->depth++;
15386         if (r->form_name) {
15387                 ndr_print_string(ndr, "form_name", r->form_name);
15388         }
15389         ndr->depth--;
15390         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15391         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15392         ndr->depth--;
15393 }
15394
15395 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15396 {
15397         if (ndr_flags & NDR_SCALARS) {
15398                 NDR_CHECK(ndr_push_align(ndr, 4));
15399                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15401                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15402                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15404                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15409         }
15410         if (ndr_flags & NDR_BUFFERS) {
15411                 if (r->form_name) {
15412                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15416                 }
15417                 if (r->keyword) {
15418                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15422                 }
15423                 if (r->mui_dll) {
15424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15427                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15428                 }
15429                 if (r->display_name) {
15430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15434                 }
15435         }
15436         return NDR_ERR_SUCCESS;
15437 }
15438
15439 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15440 {
15441         uint32_t _ptr_form_name;
15442         TALLOC_CTX *_mem_save_form_name_0;
15443         uint32_t _ptr_keyword;
15444         TALLOC_CTX *_mem_save_keyword_0;
15445         uint32_t _ptr_mui_dll;
15446         TALLOC_CTX *_mem_save_mui_dll_0;
15447         uint32_t _ptr_display_name;
15448         TALLOC_CTX *_mem_save_display_name_0;
15449         if (ndr_flags & NDR_SCALARS) {
15450                 NDR_CHECK(ndr_pull_align(ndr, 4));
15451                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15453                 if (_ptr_form_name) {
15454                         NDR_PULL_ALLOC(ndr, r->form_name);
15455                 } else {
15456                         r->form_name = NULL;
15457                 }
15458                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15459                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15461                 if (_ptr_keyword) {
15462                         NDR_PULL_ALLOC(ndr, r->keyword);
15463                 } else {
15464                         r->keyword = NULL;
15465                 }
15466                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15468                 if (_ptr_mui_dll) {
15469                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15470                 } else {
15471                         r->mui_dll = NULL;
15472                 }
15473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15475                 if (_ptr_display_name) {
15476                         NDR_PULL_ALLOC(ndr, r->display_name);
15477                 } else {
15478                         r->display_name = NULL;
15479                 }
15480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15481         }
15482         if (ndr_flags & NDR_BUFFERS) {
15483                 if (r->form_name) {
15484                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15485                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15488                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15489                                 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));
15490                         }
15491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15494                 }
15495                 if (r->keyword) {
15496                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15497                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15498                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15499                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15500                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15501                                 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));
15502                         }
15503                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15504                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15506                 }
15507                 if (r->mui_dll) {
15508                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15509                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15512                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15513                                 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));
15514                         }
15515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15518                 }
15519                 if (r->display_name) {
15520                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15521                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15522                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15523                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15524                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15525                                 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));
15526                         }
15527                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15528                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15530                 }
15531         }
15532         return NDR_ERR_SUCCESS;
15533 }
15534
15535 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15536 {
15537         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15538         ndr->depth++;
15539         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15540         ndr_print_ptr(ndr, "form_name", r->form_name);
15541         ndr->depth++;
15542         if (r->form_name) {
15543                 ndr_print_string(ndr, "form_name", r->form_name);
15544         }
15545         ndr->depth--;
15546         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15547         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15548         ndr_print_ptr(ndr, "keyword", r->keyword);
15549         ndr->depth++;
15550         if (r->keyword) {
15551                 ndr_print_string(ndr, "keyword", r->keyword);
15552         }
15553         ndr->depth--;
15554         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15555         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15556         ndr->depth++;
15557         if (r->mui_dll) {
15558                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15559         }
15560         ndr->depth--;
15561         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15562         ndr_print_ptr(ndr, "display_name", r->display_name);
15563         ndr->depth++;
15564         if (r->display_name) {
15565                 ndr_print_string(ndr, "display_name", r->display_name);
15566         }
15567         ndr->depth--;
15568         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15569         ndr->depth--;
15570 }
15571
15572 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15573 {
15574         if (ndr_flags & NDR_SCALARS) {
15575                 int level = ndr_push_get_switch_value(ndr, r);
15576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15577                 switch (level) {
15578                         case 1: {
15579                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15580                         break; }
15581
15582                         case 2: {
15583                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15584                         break; }
15585
15586                         default:
15587                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15588                 }
15589         }
15590         if (ndr_flags & NDR_BUFFERS) {
15591                 int level = ndr_push_get_switch_value(ndr, r);
15592                 switch (level) {
15593                         case 1:
15594                                 if (r->info1) {
15595                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15596                                 }
15597                         break;
15598
15599                         case 2:
15600                                 if (r->info2) {
15601                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15602                                 }
15603                         break;
15604
15605                         default:
15606                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15607                 }
15608         }
15609         return NDR_ERR_SUCCESS;
15610 }
15611
15612 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15613 {
15614         int level;
15615         uint32_t _level;
15616         TALLOC_CTX *_mem_save_info1_0;
15617         TALLOC_CTX *_mem_save_info2_0;
15618         level = ndr_pull_get_switch_value(ndr, r);
15619         if (ndr_flags & NDR_SCALARS) {
15620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15621                 if (_level != level) {
15622                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15623                 }
15624                 switch (level) {
15625                         case 1: {
15626                                 uint32_t _ptr_info1;
15627                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15628                                 if (_ptr_info1) {
15629                                         NDR_PULL_ALLOC(ndr, r->info1);
15630                                 } else {
15631                                         r->info1 = NULL;
15632                                 }
15633                         break; }
15634
15635                         case 2: {
15636                                 uint32_t _ptr_info2;
15637                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15638                                 if (_ptr_info2) {
15639                                         NDR_PULL_ALLOC(ndr, r->info2);
15640                                 } else {
15641                                         r->info2 = NULL;
15642                                 }
15643                         break; }
15644
15645                         default:
15646                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15647                 }
15648         }
15649         if (ndr_flags & NDR_BUFFERS) {
15650                 switch (level) {
15651                         case 1:
15652                                 if (r->info1) {
15653                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15654                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15655                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15656                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15657                                 }
15658                         break;
15659
15660                         case 2:
15661                                 if (r->info2) {
15662                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15663                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15664                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15665                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15666                                 }
15667                         break;
15668
15669                         default:
15670                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15671                 }
15672         }
15673         return NDR_ERR_SUCCESS;
15674 }
15675
15676 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15677 {
15678         int level;
15679         level = ndr_print_get_switch_value(ndr, r);
15680         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15681         switch (level) {
15682                 case 1:
15683                         ndr_print_ptr(ndr, "info1", r->info1);
15684                         ndr->depth++;
15685                         if (r->info1) {
15686                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15687                         }
15688                         ndr->depth--;
15689                 break;
15690
15691                 case 2:
15692                         ndr_print_ptr(ndr, "info2", r->info2);
15693                         ndr->depth++;
15694                         if (r->info2) {
15695                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15696                         }
15697                         ndr->depth--;
15698                 break;
15699
15700                 default:
15701                         ndr_print_bad_level(ndr, name, level);
15702         }
15703 }
15704
15705 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15706 {
15707         if (ndr_flags & NDR_SCALARS) {
15708                 NDR_CHECK(ndr_push_align(ndr, 4));
15709                 {
15710                         uint32_t _flags_save_string = ndr->flags;
15711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15712                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15713                         ndr->flags = _flags_save_string;
15714                 }
15715         }
15716         if (ndr_flags & NDR_BUFFERS) {
15717                 {
15718                         uint32_t _flags_save_string = ndr->flags;
15719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15720                         if (r->port_name) {
15721                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15722                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15723                         }
15724                         ndr->flags = _flags_save_string;
15725                 }
15726         }
15727         return NDR_ERR_SUCCESS;
15728 }
15729
15730 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15731 {
15732         uint32_t _ptr_port_name;
15733         TALLOC_CTX *_mem_save_port_name_0;
15734         if (ndr_flags & NDR_SCALARS) {
15735                 NDR_CHECK(ndr_pull_align(ndr, 4));
15736                 {
15737                         uint32_t _flags_save_string = ndr->flags;
15738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15740                         if (_ptr_port_name) {
15741                                 NDR_PULL_ALLOC(ndr, r->port_name);
15742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15743                         } else {
15744                                 r->port_name = NULL;
15745                         }
15746                         ndr->flags = _flags_save_string;
15747                 }
15748         }
15749         if (ndr_flags & NDR_BUFFERS) {
15750                 {
15751                         uint32_t _flags_save_string = ndr->flags;
15752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15753                         if (r->port_name) {
15754                                 uint32_t _relative_save_offset;
15755                                 _relative_save_offset = ndr->offset;
15756                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15757                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15758                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15759                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15760                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15761                                 ndr->offset = _relative_save_offset;
15762                         }
15763                         ndr->flags = _flags_save_string;
15764                 }
15765         }
15766         return NDR_ERR_SUCCESS;
15767 }
15768
15769 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15770 {
15771         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15772         ndr->depth++;
15773         ndr_print_ptr(ndr, "port_name", r->port_name);
15774         ndr->depth++;
15775         if (r->port_name) {
15776                 ndr_print_string(ndr, "port_name", r->port_name);
15777         }
15778         ndr->depth--;
15779         ndr->depth--;
15780 }
15781
15782 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15783 {
15784         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15785 }
15786
15787 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15788 {
15789         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15790         return NDR_ERR_SUCCESS;
15791 }
15792
15793 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15794 {
15795         uint32_t v;
15796         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15797         *r = v;
15798         return NDR_ERR_SUCCESS;
15799 }
15800
15801 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15802 {
15803         ndr_print_uint32(ndr, name, r);
15804         ndr->depth++;
15805         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15806         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15807         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15808         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15809         ndr->depth--;
15810 }
15811
15812 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15813 {
15814         if (ndr_flags & NDR_SCALARS) {
15815                 NDR_CHECK(ndr_push_align(ndr, 4));
15816                 {
15817                         uint32_t _flags_save_string = ndr->flags;
15818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15819                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15820                         ndr->flags = _flags_save_string;
15821                 }
15822                 {
15823                         uint32_t _flags_save_string = ndr->flags;
15824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15825                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15826                         ndr->flags = _flags_save_string;
15827                 }
15828                 {
15829                         uint32_t _flags_save_string = ndr->flags;
15830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15831                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15832                         ndr->flags = _flags_save_string;
15833                 }
15834                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15836         }
15837         if (ndr_flags & NDR_BUFFERS) {
15838                 {
15839                         uint32_t _flags_save_string = ndr->flags;
15840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15841                         if (r->port_name) {
15842                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15843                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15844                         }
15845                         ndr->flags = _flags_save_string;
15846                 }
15847                 {
15848                         uint32_t _flags_save_string = ndr->flags;
15849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15850                         if (r->monitor_name) {
15851                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15852                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15853                         }
15854                         ndr->flags = _flags_save_string;
15855                 }
15856                 {
15857                         uint32_t _flags_save_string = ndr->flags;
15858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15859                         if (r->description) {
15860                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15861                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15862                         }
15863                         ndr->flags = _flags_save_string;
15864                 }
15865         }
15866         return NDR_ERR_SUCCESS;
15867 }
15868
15869 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15870 {
15871         uint32_t _ptr_port_name;
15872         TALLOC_CTX *_mem_save_port_name_0;
15873         uint32_t _ptr_monitor_name;
15874         TALLOC_CTX *_mem_save_monitor_name_0;
15875         uint32_t _ptr_description;
15876         TALLOC_CTX *_mem_save_description_0;
15877         if (ndr_flags & NDR_SCALARS) {
15878                 NDR_CHECK(ndr_pull_align(ndr, 4));
15879                 {
15880                         uint32_t _flags_save_string = ndr->flags;
15881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15883                         if (_ptr_port_name) {
15884                                 NDR_PULL_ALLOC(ndr, r->port_name);
15885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15886                         } else {
15887                                 r->port_name = NULL;
15888                         }
15889                         ndr->flags = _flags_save_string;
15890                 }
15891                 {
15892                         uint32_t _flags_save_string = ndr->flags;
15893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15894                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15895                         if (_ptr_monitor_name) {
15896                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15897                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15898                         } else {
15899                                 r->monitor_name = NULL;
15900                         }
15901                         ndr->flags = _flags_save_string;
15902                 }
15903                 {
15904                         uint32_t _flags_save_string = ndr->flags;
15905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15906                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15907                         if (_ptr_description) {
15908                                 NDR_PULL_ALLOC(ndr, r->description);
15909                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15910                         } else {
15911                                 r->description = NULL;
15912                         }
15913                         ndr->flags = _flags_save_string;
15914                 }
15915                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15917         }
15918         if (ndr_flags & NDR_BUFFERS) {
15919                 {
15920                         uint32_t _flags_save_string = ndr->flags;
15921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15922                         if (r->port_name) {
15923                                 uint32_t _relative_save_offset;
15924                                 _relative_save_offset = ndr->offset;
15925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15926                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15927                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15930                                 ndr->offset = _relative_save_offset;
15931                         }
15932                         ndr->flags = _flags_save_string;
15933                 }
15934                 {
15935                         uint32_t _flags_save_string = ndr->flags;
15936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15937                         if (r->monitor_name) {
15938                                 uint32_t _relative_save_offset;
15939                                 _relative_save_offset = ndr->offset;
15940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15941                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15942                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15945                                 ndr->offset = _relative_save_offset;
15946                         }
15947                         ndr->flags = _flags_save_string;
15948                 }
15949                 {
15950                         uint32_t _flags_save_string = ndr->flags;
15951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15952                         if (r->description) {
15953                                 uint32_t _relative_save_offset;
15954                                 _relative_save_offset = ndr->offset;
15955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15956                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15957                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15960                                 ndr->offset = _relative_save_offset;
15961                         }
15962                         ndr->flags = _flags_save_string;
15963                 }
15964         }
15965         return NDR_ERR_SUCCESS;
15966 }
15967
15968 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15969 {
15970         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15971         ndr->depth++;
15972         ndr_print_ptr(ndr, "port_name", r->port_name);
15973         ndr->depth++;
15974         if (r->port_name) {
15975                 ndr_print_string(ndr, "port_name", r->port_name);
15976         }
15977         ndr->depth--;
15978         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15979         ndr->depth++;
15980         if (r->monitor_name) {
15981                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15982         }
15983         ndr->depth--;
15984         ndr_print_ptr(ndr, "description", r->description);
15985         ndr->depth++;
15986         if (r->description) {
15987                 ndr_print_string(ndr, "description", r->description);
15988         }
15989         ndr->depth--;
15990         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15991         ndr_print_uint32(ndr, "reserved", r->reserved);
15992         ndr->depth--;
15993 }
15994
15995 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15996 {
15997         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15998 }
15999
16000 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16001 {
16002         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16003         return NDR_ERR_SUCCESS;
16004 }
16005
16006 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16007 {
16008         uint32_t v;
16009         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16010         *r = v;
16011         return NDR_ERR_SUCCESS;
16012 }
16013
16014 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16015 {
16016         const char *val = NULL;
16017
16018         switch (r) {
16019                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16020                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16021                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16022                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16023                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16024                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16025                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16026                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16027                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16028                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16029                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16030                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16031                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16032         }
16033         ndr_print_enum(ndr, name, "ENUM", val, r);
16034 }
16035
16036 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16037 {
16038         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16039         return NDR_ERR_SUCCESS;
16040 }
16041
16042 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16043 {
16044         uint32_t v;
16045         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16046         *r = v;
16047         return NDR_ERR_SUCCESS;
16048 }
16049
16050 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16051 {
16052         const char *val = NULL;
16053
16054         switch (r) {
16055                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16056                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16057                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16058         }
16059         ndr_print_enum(ndr, name, "ENUM", val, r);
16060 }
16061
16062 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16063 {
16064         if (ndr_flags & NDR_SCALARS) {
16065                 NDR_CHECK(ndr_push_align(ndr, 4));
16066                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16067                 {
16068                         uint32_t _flags_save_string = ndr->flags;
16069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16070                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16071                         ndr->flags = _flags_save_string;
16072                 }
16073                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16074         }
16075         if (ndr_flags & NDR_BUFFERS) {
16076                 {
16077                         uint32_t _flags_save_string = ndr->flags;
16078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16079                         if (r->status_string) {
16080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16082                         }
16083                         ndr->flags = _flags_save_string;
16084                 }
16085         }
16086         return NDR_ERR_SUCCESS;
16087 }
16088
16089 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16090 {
16091         uint32_t _ptr_status_string;
16092         TALLOC_CTX *_mem_save_status_string_0;
16093         if (ndr_flags & NDR_SCALARS) {
16094                 NDR_CHECK(ndr_pull_align(ndr, 4));
16095                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16096                 {
16097                         uint32_t _flags_save_string = ndr->flags;
16098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16099                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16100                         if (_ptr_status_string) {
16101                                 NDR_PULL_ALLOC(ndr, r->status_string);
16102                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16103                         } else {
16104                                 r->status_string = NULL;
16105                         }
16106                         ndr->flags = _flags_save_string;
16107                 }
16108                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16109         }
16110         if (ndr_flags & NDR_BUFFERS) {
16111                 {
16112                         uint32_t _flags_save_string = ndr->flags;
16113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16114                         if (r->status_string) {
16115                                 uint32_t _relative_save_offset;
16116                                 _relative_save_offset = ndr->offset;
16117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16118                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16119                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16122                                 ndr->offset = _relative_save_offset;
16123                         }
16124                         ndr->flags = _flags_save_string;
16125                 }
16126         }
16127         return NDR_ERR_SUCCESS;
16128 }
16129
16130 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16131 {
16132         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16133         ndr->depth++;
16134         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16135         ndr_print_ptr(ndr, "status_string", r->status_string);
16136         ndr->depth++;
16137         if (r->status_string) {
16138                 ndr_print_string(ndr, "status_string", r->status_string);
16139         }
16140         ndr->depth--;
16141         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16142         ndr->depth--;
16143 }
16144
16145 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16146 {
16147         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16148 }
16149
16150 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16151 {
16152         if (ndr_flags & NDR_SCALARS) {
16153                 NDR_CHECK(ndr_push_align(ndr, 4));
16154                 {
16155                         uint32_t _flags_save_string = ndr->flags;
16156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16157                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16158                         ndr->flags = _flags_save_string;
16159                 }
16160                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16161         }
16162         if (ndr_flags & NDR_BUFFERS) {
16163                 {
16164                         uint32_t _flags_save_string = ndr->flags;
16165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16166                         if (r->port_name) {
16167                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16168                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16169                         }
16170                         ndr->flags = _flags_save_string;
16171                 }
16172         }
16173         return NDR_ERR_SUCCESS;
16174 }
16175
16176 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16177 {
16178         uint32_t _ptr_port_name;
16179         TALLOC_CTX *_mem_save_port_name_0;
16180         if (ndr_flags & NDR_SCALARS) {
16181                 NDR_CHECK(ndr_pull_align(ndr, 4));
16182                 {
16183                         uint32_t _flags_save_string = ndr->flags;
16184                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16185                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16186                         if (_ptr_port_name) {
16187                                 NDR_PULL_ALLOC(ndr, r->port_name);
16188                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16189                         } else {
16190                                 r->port_name = NULL;
16191                         }
16192                         ndr->flags = _flags_save_string;
16193                 }
16194                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16195         }
16196         if (ndr_flags & NDR_BUFFERS) {
16197                 {
16198                         uint32_t _flags_save_string = ndr->flags;
16199                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16200                         if (r->port_name) {
16201                                 uint32_t _relative_save_offset;
16202                                 _relative_save_offset = ndr->offset;
16203                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16204                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16205                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16206                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16207                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16208                                 ndr->offset = _relative_save_offset;
16209                         }
16210                         ndr->flags = _flags_save_string;
16211                 }
16212         }
16213         return NDR_ERR_SUCCESS;
16214 }
16215
16216 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16217 {
16218         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16219         ndr->depth++;
16220         ndr_print_ptr(ndr, "port_name", r->port_name);
16221         ndr->depth++;
16222         if (r->port_name) {
16223                 ndr_print_string(ndr, "port_name", r->port_name);
16224         }
16225         ndr->depth--;
16226         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16227         ndr->depth--;
16228 }
16229
16230 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16231 {
16232         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16233 }
16234
16235 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16236 {
16237         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16238         if (ndr_flags & NDR_SCALARS) {
16239                 int level = ndr_push_get_switch_value(ndr, r);
16240                 switch (level) {
16241                         case 1: {
16242                                 NDR_CHECK(ndr_push_align(ndr, 4));
16243                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16244                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16245                         break; }
16246
16247                         case 2: {
16248                                 NDR_CHECK(ndr_push_align(ndr, 4));
16249                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16250                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16251                         break; }
16252
16253                         case 3: {
16254                                 NDR_CHECK(ndr_push_align(ndr, 4));
16255                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16256                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16257                         break; }
16258
16259                         case 0xff: {
16260                                 NDR_CHECK(ndr_push_align(ndr, 4));
16261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16262                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16263                         break; }
16264
16265                         default: {
16266                         break; }
16267
16268                 }
16269         }
16270         if (ndr_flags & NDR_BUFFERS) {
16271                 int level = ndr_push_get_switch_value(ndr, r);
16272                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16273                 switch (level) {
16274                         case 1:
16275                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16276                         break;
16277
16278                         case 2:
16279                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16280                         break;
16281
16282                         case 3:
16283                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16284                         break;
16285
16286                         case 0xff:
16287                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16288                         break;
16289
16290                         default:
16291                         break;
16292
16293                 }
16294         }
16295         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16296         return NDR_ERR_SUCCESS;
16297 }
16298
16299 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16300 {
16301         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16302         int level;
16303         level = ndr_pull_get_switch_value(ndr, r);
16304         if (ndr_flags & NDR_SCALARS) {
16305                 switch (level) {
16306                         case 1: {
16307                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16308                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16309                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16310                         break; }
16311
16312                         case 2: {
16313                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16314                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16315                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16316                         break; }
16317
16318                         case 3: {
16319                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16320                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16321                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16322                         break; }
16323
16324                         case 0xff: {
16325                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16326                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16327                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16328                         break; }
16329
16330                         default: {
16331                         break; }
16332
16333                 }
16334         }
16335         if (ndr_flags & NDR_BUFFERS) {
16336                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16337                 switch (level) {
16338                         case 1:
16339                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16340                         break;
16341
16342                         case 2:
16343                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16344                         break;
16345
16346                         case 3:
16347                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16348                         break;
16349
16350                         case 0xff:
16351                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16352                         break;
16353
16354                         default:
16355                         break;
16356
16357                 }
16358         }
16359         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16360         return NDR_ERR_SUCCESS;
16361 }
16362
16363 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16364 {
16365         int level;
16366         level = ndr_print_get_switch_value(ndr, r);
16367         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16368         switch (level) {
16369                 case 1:
16370                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16371                 break;
16372
16373                 case 2:
16374                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16375                 break;
16376
16377                 case 3:
16378                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16379                 break;
16380
16381                 case 0xff:
16382                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16383                 break;
16384
16385                 default:
16386                 break;
16387
16388         }
16389 }
16390
16391 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16392 {
16393         if (ndr_flags & NDR_SCALARS) {
16394                 NDR_CHECK(ndr_push_align(ndr, 4));
16395                 {
16396                         uint32_t _flags_save_string = ndr->flags;
16397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16398                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16399                         ndr->flags = _flags_save_string;
16400                 }
16401         }
16402         if (ndr_flags & NDR_BUFFERS) {
16403                 {
16404                         uint32_t _flags_save_string = ndr->flags;
16405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16406                         if (r->monitor_name) {
16407                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16408                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16409                         }
16410                         ndr->flags = _flags_save_string;
16411                 }
16412         }
16413         return NDR_ERR_SUCCESS;
16414 }
16415
16416 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16417 {
16418         uint32_t _ptr_monitor_name;
16419         TALLOC_CTX *_mem_save_monitor_name_0;
16420         if (ndr_flags & NDR_SCALARS) {
16421                 NDR_CHECK(ndr_pull_align(ndr, 4));
16422                 {
16423                         uint32_t _flags_save_string = ndr->flags;
16424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16425                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16426                         if (_ptr_monitor_name) {
16427                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16428                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16429                         } else {
16430                                 r->monitor_name = NULL;
16431                         }
16432                         ndr->flags = _flags_save_string;
16433                 }
16434         }
16435         if (ndr_flags & NDR_BUFFERS) {
16436                 {
16437                         uint32_t _flags_save_string = ndr->flags;
16438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16439                         if (r->monitor_name) {
16440                                 uint32_t _relative_save_offset;
16441                                 _relative_save_offset = ndr->offset;
16442                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16443                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16444                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16445                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16446                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16447                                 ndr->offset = _relative_save_offset;
16448                         }
16449                         ndr->flags = _flags_save_string;
16450                 }
16451         }
16452         return NDR_ERR_SUCCESS;
16453 }
16454
16455 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16456 {
16457         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16458         ndr->depth++;
16459         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16460         ndr->depth++;
16461         if (r->monitor_name) {
16462                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16463         }
16464         ndr->depth--;
16465         ndr->depth--;
16466 }
16467
16468 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16469 {
16470         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16471 }
16472
16473 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16474 {
16475         if (ndr_flags & NDR_SCALARS) {
16476                 NDR_CHECK(ndr_push_align(ndr, 4));
16477                 {
16478                         uint32_t _flags_save_string = ndr->flags;
16479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16481                         ndr->flags = _flags_save_string;
16482                 }
16483                 {
16484                         uint32_t _flags_save_string = ndr->flags;
16485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16487                         ndr->flags = _flags_save_string;
16488                 }
16489                 {
16490                         uint32_t _flags_save_string = ndr->flags;
16491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16493                         ndr->flags = _flags_save_string;
16494                 }
16495         }
16496         if (ndr_flags & NDR_BUFFERS) {
16497                 {
16498                         uint32_t _flags_save_string = ndr->flags;
16499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16500                         if (r->monitor_name) {
16501                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16502                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16503                         }
16504                         ndr->flags = _flags_save_string;
16505                 }
16506                 {
16507                         uint32_t _flags_save_string = ndr->flags;
16508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16509                         if (r->environment) {
16510                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16511                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16512                         }
16513                         ndr->flags = _flags_save_string;
16514                 }
16515                 {
16516                         uint32_t _flags_save_string = ndr->flags;
16517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16518                         if (r->dll_name) {
16519                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16520                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16521                         }
16522                         ndr->flags = _flags_save_string;
16523                 }
16524         }
16525         return NDR_ERR_SUCCESS;
16526 }
16527
16528 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16529 {
16530         uint32_t _ptr_monitor_name;
16531         TALLOC_CTX *_mem_save_monitor_name_0;
16532         uint32_t _ptr_environment;
16533         TALLOC_CTX *_mem_save_environment_0;
16534         uint32_t _ptr_dll_name;
16535         TALLOC_CTX *_mem_save_dll_name_0;
16536         if (ndr_flags & NDR_SCALARS) {
16537                 NDR_CHECK(ndr_pull_align(ndr, 4));
16538                 {
16539                         uint32_t _flags_save_string = ndr->flags;
16540                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16541                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16542                         if (_ptr_monitor_name) {
16543                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16544                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16545                         } else {
16546                                 r->monitor_name = NULL;
16547                         }
16548                         ndr->flags = _flags_save_string;
16549                 }
16550                 {
16551                         uint32_t _flags_save_string = ndr->flags;
16552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16553                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16554                         if (_ptr_environment) {
16555                                 NDR_PULL_ALLOC(ndr, r->environment);
16556                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16557                         } else {
16558                                 r->environment = NULL;
16559                         }
16560                         ndr->flags = _flags_save_string;
16561                 }
16562                 {
16563                         uint32_t _flags_save_string = ndr->flags;
16564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16565                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16566                         if (_ptr_dll_name) {
16567                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16568                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16569                         } else {
16570                                 r->dll_name = NULL;
16571                         }
16572                         ndr->flags = _flags_save_string;
16573                 }
16574         }
16575         if (ndr_flags & NDR_BUFFERS) {
16576                 {
16577                         uint32_t _flags_save_string = ndr->flags;
16578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16579                         if (r->monitor_name) {
16580                                 uint32_t _relative_save_offset;
16581                                 _relative_save_offset = ndr->offset;
16582                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16583                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16584                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16585                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16586                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16587                                 ndr->offset = _relative_save_offset;
16588                         }
16589                         ndr->flags = _flags_save_string;
16590                 }
16591                 {
16592                         uint32_t _flags_save_string = ndr->flags;
16593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16594                         if (r->environment) {
16595                                 uint32_t _relative_save_offset;
16596                                 _relative_save_offset = ndr->offset;
16597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16598                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16599                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16602                                 ndr->offset = _relative_save_offset;
16603                         }
16604                         ndr->flags = _flags_save_string;
16605                 }
16606                 {
16607                         uint32_t _flags_save_string = ndr->flags;
16608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16609                         if (r->dll_name) {
16610                                 uint32_t _relative_save_offset;
16611                                 _relative_save_offset = ndr->offset;
16612                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16613                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16614                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16615                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16616                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16617                                 ndr->offset = _relative_save_offset;
16618                         }
16619                         ndr->flags = _flags_save_string;
16620                 }
16621         }
16622         return NDR_ERR_SUCCESS;
16623 }
16624
16625 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16626 {
16627         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16628         ndr->depth++;
16629         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16630         ndr->depth++;
16631         if (r->monitor_name) {
16632                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16633         }
16634         ndr->depth--;
16635         ndr_print_ptr(ndr, "environment", r->environment);
16636         ndr->depth++;
16637         if (r->environment) {
16638                 ndr_print_string(ndr, "environment", r->environment);
16639         }
16640         ndr->depth--;
16641         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16642         ndr->depth++;
16643         if (r->dll_name) {
16644                 ndr_print_string(ndr, "dll_name", r->dll_name);
16645         }
16646         ndr->depth--;
16647         ndr->depth--;
16648 }
16649
16650 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16651 {
16652         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16653 }
16654
16655 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16656 {
16657         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16658         if (ndr_flags & NDR_SCALARS) {
16659                 int level = ndr_push_get_switch_value(ndr, r);
16660                 switch (level) {
16661                         case 1: {
16662                                 NDR_CHECK(ndr_push_align(ndr, 4));
16663                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16664                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16665                         break; }
16666
16667                         case 2: {
16668                                 NDR_CHECK(ndr_push_align(ndr, 4));
16669                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16670                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16671                         break; }
16672
16673                         default: {
16674                         break; }
16675
16676                 }
16677         }
16678         if (ndr_flags & NDR_BUFFERS) {
16679                 int level = ndr_push_get_switch_value(ndr, r);
16680                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16681                 switch (level) {
16682                         case 1:
16683                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16684                         break;
16685
16686                         case 2:
16687                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16688                         break;
16689
16690                         default:
16691                         break;
16692
16693                 }
16694         }
16695         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16696         return NDR_ERR_SUCCESS;
16697 }
16698
16699 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16700 {
16701         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16702         int level;
16703         level = ndr_pull_get_switch_value(ndr, r);
16704         if (ndr_flags & NDR_SCALARS) {
16705                 switch (level) {
16706                         case 1: {
16707                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16708                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16709                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16710                         break; }
16711
16712                         case 2: {
16713                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16714                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16715                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16716                         break; }
16717
16718                         default: {
16719                         break; }
16720
16721                 }
16722         }
16723         if (ndr_flags & NDR_BUFFERS) {
16724                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16725                 switch (level) {
16726                         case 1:
16727                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16728                         break;
16729
16730                         case 2:
16731                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16732                         break;
16733
16734                         default:
16735                         break;
16736
16737                 }
16738         }
16739         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16740         return NDR_ERR_SUCCESS;
16741 }
16742
16743 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16744 {
16745         int level;
16746         level = ndr_print_get_switch_value(ndr, r);
16747         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16748         switch (level) {
16749                 case 1:
16750                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16751                 break;
16752
16753                 case 2:
16754                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16755                 break;
16756
16757                 default:
16758                 break;
16759
16760         }
16761 }
16762
16763 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16764 {
16765         if (ndr_flags & NDR_SCALARS) {
16766                 NDR_CHECK(ndr_push_align(ndr, 4));
16767                 {
16768                         uint32_t _flags_save_string = ndr->flags;
16769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16770                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16771                         ndr->flags = _flags_save_string;
16772                 }
16773         }
16774         if (ndr_flags & NDR_BUFFERS) {
16775                 {
16776                         uint32_t _flags_save_string = ndr->flags;
16777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16778                         if (r->name_array) {
16779                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16780                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16781                         }
16782                         ndr->flags = _flags_save_string;
16783                 }
16784         }
16785         return NDR_ERR_SUCCESS;
16786 }
16787
16788 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16789 {
16790         uint32_t _ptr_name_array;
16791         TALLOC_CTX *_mem_save_name_array_0;
16792         if (ndr_flags & NDR_SCALARS) {
16793                 NDR_CHECK(ndr_pull_align(ndr, 4));
16794                 {
16795                         uint32_t _flags_save_string = ndr->flags;
16796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16797                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16798                         if (_ptr_name_array) {
16799                                 NDR_PULL_ALLOC(ndr, r->name_array);
16800                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16801                         } else {
16802                                 r->name_array = NULL;
16803                         }
16804                         ndr->flags = _flags_save_string;
16805                 }
16806         }
16807         if (ndr_flags & NDR_BUFFERS) {
16808                 {
16809                         uint32_t _flags_save_string = ndr->flags;
16810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16811                         if (r->name_array) {
16812                                 uint32_t _relative_save_offset;
16813                                 _relative_save_offset = ndr->offset;
16814                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16815                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16816                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16817                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16818                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16819                                 ndr->offset = _relative_save_offset;
16820                         }
16821                         ndr->flags = _flags_save_string;
16822                 }
16823         }
16824         return NDR_ERR_SUCCESS;
16825 }
16826
16827 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16828 {
16829         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16830         ndr->depth++;
16831         ndr_print_ptr(ndr, "name_array", r->name_array);
16832         ndr->depth++;
16833         if (r->name_array) {
16834                 ndr_print_string(ndr, "name_array", r->name_array);
16835         }
16836         ndr->depth--;
16837         ndr->depth--;
16838 }
16839
16840 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16841 {
16842         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16843 }
16844
16845 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16846 {
16847         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16848         if (ndr_flags & NDR_SCALARS) {
16849                 int level = ndr_push_get_switch_value(ndr, r);
16850                 switch (level) {
16851                         case 1: {
16852                                 NDR_CHECK(ndr_push_align(ndr, 4));
16853                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16854                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16855                         break; }
16856
16857                         default: {
16858                         break; }
16859
16860                 }
16861         }
16862         if (ndr_flags & NDR_BUFFERS) {
16863                 int level = ndr_push_get_switch_value(ndr, r);
16864                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16865                 switch (level) {
16866                         case 1:
16867                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16868                         break;
16869
16870                         default:
16871                         break;
16872
16873                 }
16874         }
16875         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16876         return NDR_ERR_SUCCESS;
16877 }
16878
16879 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16880 {
16881         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16882         int level;
16883         level = ndr_pull_get_switch_value(ndr, r);
16884         if (ndr_flags & NDR_SCALARS) {
16885                 switch (level) {
16886                         case 1: {
16887                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16888                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16889                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16890                         break; }
16891
16892                         default: {
16893                         break; }
16894
16895                 }
16896         }
16897         if (ndr_flags & NDR_BUFFERS) {
16898                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16899                 switch (level) {
16900                         case 1:
16901                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16902                         break;
16903
16904                         default:
16905                         break;
16906
16907                 }
16908         }
16909         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16910         return NDR_ERR_SUCCESS;
16911 }
16912
16913 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16914 {
16915         int level;
16916         level = ndr_print_get_switch_value(ndr, r);
16917         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16918         switch (level) {
16919                 case 1:
16920                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16921                 break;
16922
16923                 default:
16924                 break;
16925
16926         }
16927 }
16928
16929 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16930 {
16931         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16932         return NDR_ERR_SUCCESS;
16933 }
16934
16935 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16936 {
16937         uint32_t v;
16938         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16939         *r = v;
16940         return NDR_ERR_SUCCESS;
16941 }
16942
16943 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16944 {
16945         ndr_print_uint32(ndr, name, r);
16946         ndr->depth++;
16947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16951         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16952         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16956         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16968         ndr->depth--;
16969 }
16970
16971 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16972 {
16973         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16974         return NDR_ERR_SUCCESS;
16975 }
16976
16977 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16978 {
16979         uint16_t v;
16980         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16981         *r = v;
16982         return NDR_ERR_SUCCESS;
16983 }
16984
16985 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16986 {
16987         const char *val = NULL;
16988
16989         switch (r) {
16990                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16991                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16992                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16993                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16994                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16995                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16996                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16997                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16998                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16999                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
17000                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
17001                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
17002                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
17003                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
17004                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
17005                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
17006                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
17007                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
17008                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
17009                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
17010                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
17011                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
17012                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
17013                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
17014                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
17015                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
17016         }
17017         ndr_print_enum(ndr, name, "ENUM", val, r);
17018 }
17019
17020 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17021 {
17022         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17023         return NDR_ERR_SUCCESS;
17024 }
17025
17026 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17027 {
17028         uint16_t v;
17029         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17030         *r = v;
17031         return NDR_ERR_SUCCESS;
17032 }
17033
17034 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17035 {
17036         const char *val = NULL;
17037
17038         switch (r) {
17039                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
17040                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
17041         }
17042         ndr_print_enum(ndr, name, "ENUM", val, r);
17043 }
17044
17045 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17046 {
17047         uint32_t cntr_fields_1;
17048         if (ndr_flags & NDR_SCALARS) {
17049                 NDR_CHECK(ndr_push_align(ndr, 4));
17050                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17051                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17056         }
17057         if (ndr_flags & NDR_BUFFERS) {
17058                 if (r->fields) {
17059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17060                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17061                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17062                         }
17063                 }
17064         }
17065         return NDR_ERR_SUCCESS;
17066 }
17067
17068 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17069 {
17070         uint32_t _ptr_fields;
17071         uint32_t cntr_fields_1;
17072         TALLOC_CTX *_mem_save_fields_0;
17073         TALLOC_CTX *_mem_save_fields_1;
17074         if (ndr_flags & NDR_SCALARS) {
17075                 NDR_CHECK(ndr_pull_align(ndr, 4));
17076                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17077                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17082                 if (_ptr_fields) {
17083                         NDR_PULL_ALLOC(ndr, r->fields);
17084                 } else {
17085                         r->fields = NULL;
17086                 }
17087         }
17088         if (ndr_flags & NDR_BUFFERS) {
17089                 if (r->fields) {
17090                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17091                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17093                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17094                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17095                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17096                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17097                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17098                         }
17099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17101                 }
17102                 if (r->fields) {
17103                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17104                 }
17105         }
17106         return NDR_ERR_SUCCESS;
17107 }
17108
17109 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17110 {
17111         uint32_t cntr_fields_1;
17112         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17113         ndr->depth++;
17114         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17115         ndr_print_uint16(ndr, "u1", r->u1);
17116         ndr_print_uint32(ndr, "u2", r->u2);
17117         ndr_print_uint32(ndr, "u3", r->u3);
17118         ndr_print_uint32(ndr, "count", r->count);
17119         ndr_print_ptr(ndr, "fields", r->fields);
17120         ndr->depth++;
17121         if (r->fields) {
17122                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17123                 ndr->depth++;
17124                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17125                         char *idx_1=NULL;
17126                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17127                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17128                                 free(idx_1);
17129                         }
17130                 }
17131                 ndr->depth--;
17132         }
17133         ndr->depth--;
17134         ndr->depth--;
17135 }
17136
17137 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17138 {
17139         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17140         return NDR_ERR_SUCCESS;
17141 }
17142
17143 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17144 {
17145         uint32_t v;
17146         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17147         *r = v;
17148         return NDR_ERR_SUCCESS;
17149 }
17150
17151 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17152 {
17153         ndr_print_uint32(ndr, name, r);
17154         ndr->depth++;
17155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17156         ndr->depth--;
17157 }
17158
17159 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17160 {
17161         uint32_t cntr_types_1;
17162         if (ndr_flags & NDR_SCALARS) {
17163                 NDR_CHECK(ndr_push_align(ndr, 4));
17164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17165                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17168         }
17169         if (ndr_flags & NDR_BUFFERS) {
17170                 if (r->types) {
17171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17172                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17173                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17174                         }
17175                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17176                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17177                         }
17178                 }
17179         }
17180         return NDR_ERR_SUCCESS;
17181 }
17182
17183 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17184 {
17185         uint32_t _ptr_types;
17186         uint32_t cntr_types_1;
17187         TALLOC_CTX *_mem_save_types_0;
17188         TALLOC_CTX *_mem_save_types_1;
17189         if (ndr_flags & NDR_SCALARS) {
17190                 NDR_CHECK(ndr_pull_align(ndr, 4));
17191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17192                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17195                 if (_ptr_types) {
17196                         NDR_PULL_ALLOC(ndr, r->types);
17197                 } else {
17198                         r->types = NULL;
17199                 }
17200         }
17201         if (ndr_flags & NDR_BUFFERS) {
17202                 if (r->types) {
17203                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17204                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17206                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17207                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17208                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17209                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17210                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17211                         }
17212                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17213                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17214                         }
17215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17217                 }
17218                 if (r->types) {
17219                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17220                 }
17221         }
17222         return NDR_ERR_SUCCESS;
17223 }
17224
17225 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17226 {
17227         uint32_t cntr_types_1;
17228         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17229         ndr->depth++;
17230         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17231         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17232         ndr_print_uint32(ndr, "count", r->count);
17233         ndr_print_ptr(ndr, "types", r->types);
17234         ndr->depth++;
17235         if (r->types) {
17236                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17237                 ndr->depth++;
17238                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17239                         char *idx_1=NULL;
17240                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17241                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17242                                 free(idx_1);
17243                         }
17244                 }
17245                 ndr->depth--;
17246         }
17247         ndr->depth--;
17248         ndr->depth--;
17249 }
17250
17251 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17252 {
17253         if (ndr_flags & NDR_SCALARS) {
17254                 NDR_CHECK(ndr_push_align(ndr, 4));
17255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17257         }
17258         if (ndr_flags & NDR_BUFFERS) {
17259                 if (r->string) {
17260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17261                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17262                 }
17263         }
17264         return NDR_ERR_SUCCESS;
17265 }
17266
17267 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17268 {
17269         uint32_t _ptr_string;
17270         TALLOC_CTX *_mem_save_string_0;
17271         if (ndr_flags & NDR_SCALARS) {
17272                 NDR_CHECK(ndr_pull_align(ndr, 4));
17273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17275                 if (_ptr_string) {
17276                         NDR_PULL_ALLOC(ndr, r->string);
17277                 } else {
17278                         r->string = NULL;
17279                 }
17280         }
17281         if (ndr_flags & NDR_BUFFERS) {
17282                 if (r->string) {
17283                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17284                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17288                 }
17289                 if (r->string) {
17290                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17291                 }
17292         }
17293         return NDR_ERR_SUCCESS;
17294 }
17295
17296 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17297 {
17298         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17299         ndr->depth++;
17300         ndr_print_uint32(ndr, "size", r->size);
17301         ndr_print_ptr(ndr, "string", r->string);
17302         ndr->depth++;
17303         if (r->string) {
17304                 ndr_print_string(ndr, "string", r->string);
17305         }
17306         ndr->depth--;
17307         ndr->depth--;
17308 }
17309
17310 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17311 {
17312         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17313         return NDR_ERR_SUCCESS;
17314 }
17315
17316 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17317 {
17318         uint32_t v;
17319         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17320         *r = v;
17321         return NDR_ERR_SUCCESS;
17322 }
17323
17324 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17325 {
17326         const char *val = NULL;
17327
17328         switch (r) {
17329                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17330                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17331                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17332                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17333                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17334         }
17335         ndr_print_enum(ndr, name, "ENUM", val, r);
17336 }
17337
17338 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17339 {
17340         if (ndr_flags & NDR_SCALARS) {
17341                 int level = ndr_push_get_switch_value(ndr, r);
17342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17343                 switch (level) {
17344                         case 1: {
17345                                 uint32_t cntr_integer_0;
17346                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17347                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17348                                 }
17349                         break; }
17350
17351                         case 2: {
17352                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17353                         break; }
17354
17355                         case 3: {
17356                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17357                         break; }
17358
17359                         case 4: {
17360                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17361                         break; }
17362
17363                         case 5: {
17364                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17365                         break; }
17366
17367                         default:
17368                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17369                 }
17370         }
17371         if (ndr_flags & NDR_BUFFERS) {
17372                 int level = ndr_push_get_switch_value(ndr, r);
17373                 switch (level) {
17374                         case 1:
17375                         break;
17376
17377                         case 2:
17378                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17379                         break;
17380
17381                         case 3:
17382                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17383                         break;
17384
17385                         case 4:
17386                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17387                         break;
17388
17389                         case 5:
17390                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17391                         break;
17392
17393                         default:
17394                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17395                 }
17396         }
17397         return NDR_ERR_SUCCESS;
17398 }
17399
17400 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17401 {
17402         int level;
17403         uint32_t _level;
17404         level = ndr_pull_get_switch_value(ndr, r);
17405         if (ndr_flags & NDR_SCALARS) {
17406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17407                 if (_level != level) {
17408                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17409                 }
17410                 switch (level) {
17411                         case 1: {
17412                                 uint32_t cntr_integer_0;
17413                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17414                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17415                                 }
17416                         break; }
17417
17418                         case 2: {
17419                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17420                         break; }
17421
17422                         case 3: {
17423                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17424                         break; }
17425
17426                         case 4: {
17427                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17428                         break; }
17429
17430                         case 5: {
17431                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17432                         break; }
17433
17434                         default:
17435                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17436                 }
17437         }
17438         if (ndr_flags & NDR_BUFFERS) {
17439                 switch (level) {
17440                         case 1:
17441                         break;
17442
17443                         case 2:
17444                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17445                         break;
17446
17447                         case 3:
17448                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17449                         break;
17450
17451                         case 4:
17452                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17453                         break;
17454
17455                         case 5:
17456                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17457                         break;
17458
17459                         default:
17460                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17461                 }
17462         }
17463         return NDR_ERR_SUCCESS;
17464 }
17465
17466 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17467 {
17468         int level;
17469         uint32_t cntr_integer_0;
17470         level = ndr_print_get_switch_value(ndr, r);
17471         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17472         switch (level) {
17473                 case 1:
17474                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17475                         ndr->depth++;
17476                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17477                                 char *idx_0=NULL;
17478                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17479                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17480                                         free(idx_0);
17481                                 }
17482                         }
17483                         ndr->depth--;
17484                 break;
17485
17486                 case 2:
17487                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17488                 break;
17489
17490                 case 3:
17491                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17492                 break;
17493
17494                 case 4:
17495                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17496                 break;
17497
17498                 case 5:
17499                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17500                 break;
17501
17502                 default:
17503                         ndr_print_bad_level(ndr, name, level);
17504         }
17505 }
17506
17507 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17508 {
17509         if (ndr_flags & NDR_SCALARS) {
17510                 NDR_CHECK(ndr_push_align(ndr, 4));
17511                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17512                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17513                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17515                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17516                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17517         }
17518         if (ndr_flags & NDR_BUFFERS) {
17519                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17520         }
17521         return NDR_ERR_SUCCESS;
17522 }
17523
17524 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17525 {
17526         if (ndr_flags & NDR_SCALARS) {
17527                 NDR_CHECK(ndr_pull_align(ndr, 4));
17528                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17529                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17530                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17532                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17533                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17534         }
17535         if (ndr_flags & NDR_BUFFERS) {
17536                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17537         }
17538         return NDR_ERR_SUCCESS;
17539 }
17540
17541 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17542 {
17543         ndr_print_struct(ndr, name, "spoolss_Notify");
17544         ndr->depth++;
17545         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17546         ndr_print_spoolss_Field(ndr, "field", r->field);
17547         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17548         ndr_print_uint32(ndr, "job_id", r->job_id);
17549         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17550         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17551         ndr->depth--;
17552 }
17553
17554 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17555 {
17556         uint32_t cntr_notifies_0;
17557         if (ndr_flags & NDR_SCALARS) {
17558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17559                 NDR_CHECK(ndr_push_align(ndr, 4));
17560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17563                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17564                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17565                 }
17566         }
17567         if (ndr_flags & NDR_BUFFERS) {
17568                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17569                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17570                 }
17571         }
17572         return NDR_ERR_SUCCESS;
17573 }
17574
17575 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17576 {
17577         uint32_t cntr_notifies_0;
17578         TALLOC_CTX *_mem_save_notifies_0;
17579         if (ndr_flags & NDR_SCALARS) {
17580                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17581                 NDR_CHECK(ndr_pull_align(ndr, 4));
17582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17585                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17586                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17587                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17588                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17589                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17590                 }
17591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17592                 if (r->notifies) {
17593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17594                 }
17595         }
17596         if (ndr_flags & NDR_BUFFERS) {
17597                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17598                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17599                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17600                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17601                 }
17602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17603         }
17604         return NDR_ERR_SUCCESS;
17605 }
17606
17607 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17608 {
17609         uint32_t cntr_notifies_0;
17610         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17611         ndr->depth++;
17612         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17613         ndr_print_uint32(ndr, "flags", r->flags);
17614         ndr_print_uint32(ndr, "count", r->count);
17615         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17616         ndr->depth++;
17617         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17618                 char *idx_0=NULL;
17619                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17620                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17621                         free(idx_0);
17622                 }
17623         }
17624         ndr->depth--;
17625         ndr->depth--;
17626 }
17627
17628 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17629 {
17630         if (ndr_flags & NDR_SCALARS) {
17631                 int level = ndr_push_get_switch_value(ndr, r);
17632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17633                 switch (level) {
17634                         case 0: {
17635                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17636                         break; }
17637
17638                         default:
17639                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17640                 }
17641         }
17642         if (ndr_flags & NDR_BUFFERS) {
17643                 int level = ndr_push_get_switch_value(ndr, r);
17644                 switch (level) {
17645                         case 0:
17646                                 if (r->info0) {
17647                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17648                                 }
17649                         break;
17650
17651                         default:
17652                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17653                 }
17654         }
17655         return NDR_ERR_SUCCESS;
17656 }
17657
17658 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17659 {
17660         int level;
17661         uint32_t _level;
17662         TALLOC_CTX *_mem_save_info0_0;
17663         level = ndr_pull_get_switch_value(ndr, r);
17664         if (ndr_flags & NDR_SCALARS) {
17665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17666                 if (_level != level) {
17667                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17668                 }
17669                 switch (level) {
17670                         case 0: {
17671                                 uint32_t _ptr_info0;
17672                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17673                                 if (_ptr_info0) {
17674                                         NDR_PULL_ALLOC(ndr, r->info0);
17675                                 } else {
17676                                         r->info0 = NULL;
17677                                 }
17678                         break; }
17679
17680                         default:
17681                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17682                 }
17683         }
17684         if (ndr_flags & NDR_BUFFERS) {
17685                 switch (level) {
17686                         case 0:
17687                                 if (r->info0) {
17688                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17689                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17690                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17691                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17692                                 }
17693                         break;
17694
17695                         default:
17696                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17697                 }
17698         }
17699         return NDR_ERR_SUCCESS;
17700 }
17701
17702 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17703 {
17704         int level;
17705         level = ndr_print_get_switch_value(ndr, r);
17706         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17707         switch (level) {
17708                 case 0:
17709                         ndr_print_ptr(ndr, "info0", r->info0);
17710                         ndr->depth++;
17711                         if (r->info0) {
17712                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17713                         }
17714                         ndr->depth--;
17715                 break;
17716
17717                 default:
17718                         ndr_print_bad_level(ndr, name, level);
17719         }
17720 }
17721
17722 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17723 {
17724         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17725         return NDR_ERR_SUCCESS;
17726 }
17727
17728 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17729 {
17730         uint32_t v;
17731         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17732         *r = v;
17733         return NDR_ERR_SUCCESS;
17734 }
17735
17736 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17737 {
17738         ndr_print_uint32(ndr, name, r);
17739         ndr->depth++;
17740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17743         ndr->depth--;
17744 }
17745
17746 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17747 {
17748         if (ndr_flags & NDR_SCALARS) {
17749                 NDR_CHECK(ndr_push_align(ndr, 4));
17750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17753                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17754                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17755                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17756                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17757         }
17758         if (ndr_flags & NDR_BUFFERS) {
17759                 if (r->client) {
17760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17764                 }
17765                 if (r->user) {
17766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17770                 }
17771         }
17772         return NDR_ERR_SUCCESS;
17773 }
17774
17775 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17776 {
17777         uint32_t _ptr_client;
17778         TALLOC_CTX *_mem_save_client_0;
17779         uint32_t _ptr_user;
17780         TALLOC_CTX *_mem_save_user_0;
17781         if (ndr_flags & NDR_SCALARS) {
17782                 NDR_CHECK(ndr_pull_align(ndr, 4));
17783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17785                 if (_ptr_client) {
17786                         NDR_PULL_ALLOC(ndr, r->client);
17787                 } else {
17788                         r->client = NULL;
17789                 }
17790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17791                 if (_ptr_user) {
17792                         NDR_PULL_ALLOC(ndr, r->user);
17793                 } else {
17794                         r->user = NULL;
17795                 }
17796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17797                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17798                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17799                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17800         }
17801         if (ndr_flags & NDR_BUFFERS) {
17802                 if (r->client) {
17803                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17804                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17807                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17808                                 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));
17809                         }
17810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17813                 }
17814                 if (r->user) {
17815                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17816                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17819                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17820                                 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));
17821                         }
17822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17825                 }
17826         }
17827         return NDR_ERR_SUCCESS;
17828 }
17829
17830 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17831 {
17832         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17833         ndr->depth++;
17834         ndr_print_uint32(ndr, "size", r->size);
17835         ndr_print_ptr(ndr, "client", r->client);
17836         ndr->depth++;
17837         if (r->client) {
17838                 ndr_print_string(ndr, "client", r->client);
17839         }
17840         ndr->depth--;
17841         ndr_print_ptr(ndr, "user", r->user);
17842         ndr->depth++;
17843         if (r->user) {
17844                 ndr_print_string(ndr, "user", r->user);
17845         }
17846         ndr->depth--;
17847         ndr_print_uint32(ndr, "build", r->build);
17848         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17849         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17850         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17851         ndr->depth--;
17852 }
17853
17854 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17855 {
17856         if (ndr_flags & NDR_SCALARS) {
17857                 NDR_CHECK(ndr_push_align(ndr, 4));
17858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17859         }
17860         if (ndr_flags & NDR_BUFFERS) {
17861         }
17862         return NDR_ERR_SUCCESS;
17863 }
17864
17865 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17866 {
17867         if (ndr_flags & NDR_SCALARS) {
17868                 NDR_CHECK(ndr_pull_align(ndr, 4));
17869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17870         }
17871         if (ndr_flags & NDR_BUFFERS) {
17872         }
17873         return NDR_ERR_SUCCESS;
17874 }
17875
17876 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17877 {
17878         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17879         ndr->depth++;
17880         ndr_print_uint32(ndr, "not_used", r->not_used);
17881         ndr->depth--;
17882 }
17883
17884 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17885 {
17886         if (ndr_flags & NDR_SCALARS) {
17887                 NDR_CHECK(ndr_push_align(ndr, 4));
17888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17894                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17895                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17896                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17897                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17898         }
17899         if (ndr_flags & NDR_BUFFERS) {
17900                 if (r->client) {
17901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17904                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17905                 }
17906                 if (r->user) {
17907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17910                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17911                 }
17912         }
17913         return NDR_ERR_SUCCESS;
17914 }
17915
17916 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17917 {
17918         uint32_t _ptr_client;
17919         TALLOC_CTX *_mem_save_client_0;
17920         uint32_t _ptr_user;
17921         TALLOC_CTX *_mem_save_user_0;
17922         if (ndr_flags & NDR_SCALARS) {
17923                 NDR_CHECK(ndr_pull_align(ndr, 4));
17924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17927                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17928                 if (_ptr_client) {
17929                         NDR_PULL_ALLOC(ndr, r->client);
17930                 } else {
17931                         r->client = NULL;
17932                 }
17933                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17934                 if (_ptr_user) {
17935                         NDR_PULL_ALLOC(ndr, r->user);
17936                 } else {
17937                         r->user = NULL;
17938                 }
17939                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17940                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17941                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17942                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17943                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17944         }
17945         if (ndr_flags & NDR_BUFFERS) {
17946                 if (r->client) {
17947                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17948                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17949                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17950                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17951                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17952                                 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));
17953                         }
17954                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17955                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17957                 }
17958                 if (r->user) {
17959                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17960                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17962                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17963                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17964                                 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));
17965                         }
17966                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17967                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17969                 }
17970         }
17971         return NDR_ERR_SUCCESS;
17972 }
17973
17974 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17975 {
17976         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17977         ndr->depth++;
17978         ndr_print_uint32(ndr, "size", r->size);
17979         ndr_print_uint32(ndr, "flags", r->flags);
17980         ndr_print_uint32(ndr, "size2", r->size2);
17981         ndr_print_ptr(ndr, "client", r->client);
17982         ndr->depth++;
17983         if (r->client) {
17984                 ndr_print_string(ndr, "client", r->client);
17985         }
17986         ndr->depth--;
17987         ndr_print_ptr(ndr, "user", r->user);
17988         ndr->depth++;
17989         if (r->user) {
17990                 ndr_print_string(ndr, "user", r->user);
17991         }
17992         ndr->depth--;
17993         ndr_print_uint32(ndr, "build", r->build);
17994         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17995         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17996         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17997         ndr_print_udlong(ndr, "reserved", r->reserved);
17998         ndr->depth--;
17999 }
18000
18001 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18002 {
18003         if (ndr_flags & NDR_SCALARS) {
18004                 int level = ndr_push_get_switch_value(ndr, r);
18005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18006                 switch (level) {
18007                         case 1: {
18008                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18009                         break; }
18010
18011                         case 2: {
18012                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18013                         break; }
18014
18015                         case 3: {
18016                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18017                         break; }
18018
18019                         default:
18020                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18021                 }
18022         }
18023         if (ndr_flags & NDR_BUFFERS) {
18024                 int level = ndr_push_get_switch_value(ndr, r);
18025                 switch (level) {
18026                         case 1:
18027                                 if (r->level1) {
18028                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18029                                 }
18030                         break;
18031
18032                         case 2:
18033                                 if (r->level2) {
18034                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18035                                 }
18036                         break;
18037
18038                         case 3:
18039                                 if (r->level3) {
18040                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18041                                 }
18042                         break;
18043
18044                         default:
18045                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18046                 }
18047         }
18048         return NDR_ERR_SUCCESS;
18049 }
18050
18051 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18052 {
18053         int level;
18054         uint32_t _level;
18055         TALLOC_CTX *_mem_save_level1_0;
18056         TALLOC_CTX *_mem_save_level2_0;
18057         TALLOC_CTX *_mem_save_level3_0;
18058         level = ndr_pull_get_switch_value(ndr, r);
18059         if (ndr_flags & NDR_SCALARS) {
18060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18061                 if (_level != level) {
18062                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18063                 }
18064                 switch (level) {
18065                         case 1: {
18066                                 uint32_t _ptr_level1;
18067                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18068                                 if (_ptr_level1) {
18069                                         NDR_PULL_ALLOC(ndr, r->level1);
18070                                 } else {
18071                                         r->level1 = NULL;
18072                                 }
18073                         break; }
18074
18075                         case 2: {
18076                                 uint32_t _ptr_level2;
18077                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18078                                 if (_ptr_level2) {
18079                                         NDR_PULL_ALLOC(ndr, r->level2);
18080                                 } else {
18081                                         r->level2 = NULL;
18082                                 }
18083                         break; }
18084
18085                         case 3: {
18086                                 uint32_t _ptr_level3;
18087                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18088                                 if (_ptr_level3) {
18089                                         NDR_PULL_ALLOC(ndr, r->level3);
18090                                 } else {
18091                                         r->level3 = NULL;
18092                                 }
18093                         break; }
18094
18095                         default:
18096                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18097                 }
18098         }
18099         if (ndr_flags & NDR_BUFFERS) {
18100                 switch (level) {
18101                         case 1:
18102                                 if (r->level1) {
18103                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18104                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18105                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18106                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18107                                 }
18108                         break;
18109
18110                         case 2:
18111                                 if (r->level2) {
18112                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18113                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18114                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18115                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18116                                 }
18117                         break;
18118
18119                         case 3:
18120                                 if (r->level3) {
18121                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18122                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18123                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18125                                 }
18126                         break;
18127
18128                         default:
18129                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18130                 }
18131         }
18132         return NDR_ERR_SUCCESS;
18133 }
18134
18135 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18136 {
18137         int level;
18138         level = ndr_print_get_switch_value(ndr, r);
18139         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18140         switch (level) {
18141                 case 1:
18142                         ndr_print_ptr(ndr, "level1", r->level1);
18143                         ndr->depth++;
18144                         if (r->level1) {
18145                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18146                         }
18147                         ndr->depth--;
18148                 break;
18149
18150                 case 2:
18151                         ndr_print_ptr(ndr, "level2", r->level2);
18152                         ndr->depth++;
18153                         if (r->level2) {
18154                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18155                         }
18156                         ndr->depth--;
18157                 break;
18158
18159                 case 3:
18160                         ndr_print_ptr(ndr, "level3", r->level3);
18161                         ndr->depth++;
18162                         if (r->level3) {
18163                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18164                         }
18165                         ndr->depth--;
18166                 break;
18167
18168                 default:
18169                         ndr_print_bad_level(ndr, name, level);
18170         }
18171 }
18172
18173 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18174 {
18175         if (ndr_flags & NDR_SCALARS) {
18176                 NDR_CHECK(ndr_push_align(ndr, 4));
18177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18178                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18179                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18180         }
18181         if (ndr_flags & NDR_BUFFERS) {
18182                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18183         }
18184         return NDR_ERR_SUCCESS;
18185 }
18186
18187 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18188 {
18189         if (ndr_flags & NDR_SCALARS) {
18190                 NDR_CHECK(ndr_pull_align(ndr, 4));
18191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18192                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18193                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18194         }
18195         if (ndr_flags & NDR_BUFFERS) {
18196                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18197         }
18198         return NDR_ERR_SUCCESS;
18199 }
18200
18201 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18202 {
18203         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18204         ndr->depth++;
18205         ndr_print_uint32(ndr, "level", r->level);
18206         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18207         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18208         ndr->depth--;
18209 }
18210
18211 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18212 {
18213         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18214         return NDR_ERR_SUCCESS;
18215 }
18216
18217 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18218 {
18219         uint32_t v;
18220         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18221         *r = v;
18222         return NDR_ERR_SUCCESS;
18223 }
18224
18225 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18226 {
18227         ndr_print_uint32(ndr, name, r);
18228         ndr->depth++;
18229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18231         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18232         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18233         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18234         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18235         ndr->depth--;
18236 }
18237
18238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18239 {
18240         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18241         return NDR_ERR_SUCCESS;
18242 }
18243
18244 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18245 {
18246         uint32_t v;
18247         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18248         *r = v;
18249         return NDR_ERR_SUCCESS;
18250 }
18251
18252 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18253 {
18254         ndr_print_uint32(ndr, name, r);
18255         ndr->depth++;
18256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18259         ndr->depth--;
18260 }
18261
18262 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18263 {
18264         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18265         return NDR_ERR_SUCCESS;
18266 }
18267
18268 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18269 {
18270         uint32_t v;
18271         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18272         *r = v;
18273         return NDR_ERR_SUCCESS;
18274 }
18275
18276 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18277 {
18278         const char *val = NULL;
18279
18280         switch (r) {
18281                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18282                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18283         }
18284         ndr_print_enum(ndr, name, "ENUM", val, r);
18285 }
18286
18287 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18288 {
18289         if (ndr_flags & NDR_SCALARS) {
18290                 NDR_CHECK(ndr_push_align(ndr, 4));
18291                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18293                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18296                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18297                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18299                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18300                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18301                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18302                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18306         }
18307         if (ndr_flags & NDR_BUFFERS) {
18308         }
18309         return NDR_ERR_SUCCESS;
18310 }
18311
18312 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18313 {
18314         if (ndr_flags & NDR_SCALARS) {
18315                 NDR_CHECK(ndr_pull_align(ndr, 4));
18316                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18318                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18321                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18322                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18324                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18325                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18326                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18327                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18331         }
18332         if (ndr_flags & NDR_BUFFERS) {
18333         }
18334         return NDR_ERR_SUCCESS;
18335 }
18336
18337 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18338 {
18339         ndr_print_struct(ndr, name, "spoolss_PortData1");
18340         ndr->depth++;
18341         ndr_print_string(ndr, "portname", r->portname);
18342         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18343         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18344         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18345         ndr_print_uint32(ndr, "reserved", r->reserved);
18346         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18347         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18348         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18349         ndr_print_string(ndr, "queue", r->queue);
18350         ndr_print_string(ndr, "ip_address", r->ip_address);
18351         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18352         ndr_print_string(ndr, "device_type", r->device_type);
18353         ndr_print_uint32(ndr, "port_number", r->port_number);
18354         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18355         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18356         ndr->depth--;
18357 }
18358
18359 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18360 {
18361         if (ndr_flags & NDR_SCALARS) {
18362                 NDR_CHECK(ndr_push_align(ndr, 4));
18363                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18365                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18368                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18369                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18371                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18372                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18377         }
18378         if (ndr_flags & NDR_BUFFERS) {
18379         }
18380         return NDR_ERR_SUCCESS;
18381 }
18382
18383 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18384 {
18385         if (ndr_flags & NDR_SCALARS) {
18386                 NDR_CHECK(ndr_pull_align(ndr, 4));
18387                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18389                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18392                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18393                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18395                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18396                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18400                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18401         }
18402         if (ndr_flags & NDR_BUFFERS) {
18403         }
18404         return NDR_ERR_SUCCESS;
18405 }
18406
18407 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18408 {
18409         ndr_print_struct(ndr, name, "spoolss_PortData2");
18410         ndr->depth++;
18411         ndr_print_string(ndr, "portname", r->portname);
18412         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18413         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18414         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18415         ndr_print_uint32(ndr, "reserved", r->reserved);
18416         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18417         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18418         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18419         ndr_print_string(ndr, "queue", r->queue);
18420         ndr_print_string(ndr, "device_type", r->device_type);
18421         ndr_print_uint32(ndr, "port_number", r->port_number);
18422         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18423         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18424         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18425         ndr->depth--;
18426 }
18427
18428 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18429 {
18430         if (ndr_flags & NDR_SCALARS) {
18431                 NDR_CHECK(ndr_push_align(ndr, 4));
18432                 {
18433                         uint32_t _flags_save_string = ndr->flags;
18434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18435                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18436                         ndr->flags = _flags_save_string;
18437                 }
18438         }
18439         if (ndr_flags & NDR_BUFFERS) {
18440         }
18441         return NDR_ERR_SUCCESS;
18442 }
18443
18444 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18445 {
18446         if (ndr_flags & NDR_SCALARS) {
18447                 NDR_CHECK(ndr_pull_align(ndr, 4));
18448                 {
18449                         uint32_t _flags_save_string = ndr->flags;
18450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18451                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18452                         ndr->flags = _flags_save_string;
18453                 }
18454         }
18455         if (ndr_flags & NDR_BUFFERS) {
18456         }
18457         return NDR_ERR_SUCCESS;
18458 }
18459
18460 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18461 {
18462         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18463         ndr->depth++;
18464         ndr_print_string(ndr, "dll_name", r->dll_name);
18465         ndr->depth--;
18466 }
18467
18468 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18469 {
18470         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18471         return NDR_ERR_SUCCESS;
18472 }
18473
18474 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18475 {
18476         uint32_t v;
18477         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18478         *r = v;
18479         return NDR_ERR_SUCCESS;
18480 }
18481
18482 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18483 {
18484         ndr_print_uint32(ndr, name, r);
18485         ndr->depth++;
18486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18490         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18491         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18492         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18493         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18494         ndr->depth--;
18495 }
18496
18497 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18498 {
18499         if (flags & NDR_IN) {
18500                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18502                 if (r->in.server) {
18503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18504                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18506                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18507                 }
18508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18509                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18510                 if (r->in.buffer) {
18511                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18512                 }
18513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18514         }
18515         if (flags & NDR_OUT) {
18516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18517                 if (r->out.info) {
18518                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18519                 }
18520                 if (r->out.needed == NULL) {
18521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18522                 }
18523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18524                 if (r->out.count == NULL) {
18525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18526                 }
18527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18528                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18529         }
18530         return NDR_ERR_SUCCESS;
18531 }
18532
18533 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18534 {
18535         uint32_t _ptr_server;
18536         uint32_t _ptr_buffer;
18537         uint32_t _ptr_info;
18538         TALLOC_CTX *_mem_save_server_0;
18539         TALLOC_CTX *_mem_save_buffer_0;
18540         TALLOC_CTX *_mem_save_info_0;
18541         TALLOC_CTX *_mem_save_needed_0;
18542         TALLOC_CTX *_mem_save_count_0;
18543         if (flags & NDR_IN) {
18544                 ZERO_STRUCT(r->out);
18545
18546                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18547                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18548                 if (_ptr_server) {
18549                         NDR_PULL_ALLOC(ndr, r->in.server);
18550                 } else {
18551                         r->in.server = NULL;
18552                 }
18553                 if (r->in.server) {
18554                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18555                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18556                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18557                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18558                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18559                                 return 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));
18560                         }
18561                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18562                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18564                 }
18565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18567                 if (_ptr_buffer) {
18568                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18569                 } else {
18570                         r->in.buffer = NULL;
18571                 }
18572                 if (r->in.buffer) {
18573                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18574                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18575                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18576                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18577                 }
18578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18579                 NDR_PULL_ALLOC(ndr, r->out.needed);
18580                 ZERO_STRUCTP(r->out.needed);
18581                 NDR_PULL_ALLOC(ndr, r->out.count);
18582                 ZERO_STRUCTP(r->out.count);
18583         }
18584         if (flags & NDR_OUT) {
18585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18586                 if (_ptr_info) {
18587                         NDR_PULL_ALLOC(ndr, r->out.info);
18588                 } else {
18589                         r->out.info = NULL;
18590                 }
18591                 if (r->out.info) {
18592                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18593                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18594                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18596                 }
18597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18598                         NDR_PULL_ALLOC(ndr, r->out.needed);
18599                 }
18600                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18601                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18604                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18605                         NDR_PULL_ALLOC(ndr, r->out.count);
18606                 }
18607                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18608                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18612         }
18613         return NDR_ERR_SUCCESS;
18614 }
18615
18616 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18617 {
18618         uint32_t cntr_info_0;
18619         if (flags & NDR_IN) {
18620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18622         }
18623         if (flags & NDR_OUT) {
18624                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18625                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18626                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18627                 }
18628                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18629                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18630                 }
18631         }
18632         return NDR_ERR_SUCCESS;
18633 }
18634
18635 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18636 {
18637         uint32_t cntr_info_0;
18638         TALLOC_CTX *_mem_save_info_0;
18639         if (flags & NDR_IN) {
18640                 ZERO_STRUCT(r->out);
18641
18642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18644         }
18645         if (flags & NDR_OUT) {
18646                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18647                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18648                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18649                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18650                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18651                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18652                 }
18653                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18654                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18655                 }
18656                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18657         }
18658         return NDR_ERR_SUCCESS;
18659 }
18660
18661 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18662 {
18663         uint32_t cntr_info_2;
18664         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18665         ndr->depth++;
18666         if (flags & NDR_SET_VALUES) {
18667                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18668         }
18669         if (flags & NDR_IN) {
18670                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18671                 ndr->depth++;
18672                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18673                 ndr_print_ptr(ndr, "server", r->in.server);
18674                 ndr->depth++;
18675                 if (r->in.server) {
18676                         ndr_print_string(ndr, "server", r->in.server);
18677                 }
18678                 ndr->depth--;
18679                 ndr_print_uint32(ndr, "level", r->in.level);
18680                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18681                 ndr->depth++;
18682                 if (r->in.buffer) {
18683                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18684                 }
18685                 ndr->depth--;
18686                 ndr_print_uint32(ndr, "offered", r->in.offered);
18687                 ndr->depth--;
18688         }
18689         if (flags & NDR_OUT) {
18690                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18691                 ndr->depth++;
18692                 ndr_print_ptr(ndr, "count", r->out.count);
18693                 ndr->depth++;
18694                 ndr_print_uint32(ndr, "count", *r->out.count);
18695                 ndr->depth--;
18696                 ndr_print_ptr(ndr, "info", r->out.info);
18697                 ndr->depth++;
18698                 ndr_print_ptr(ndr, "info", *r->out.info);
18699                 ndr->depth++;
18700                 if (*r->out.info) {
18701                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18702                         ndr->depth++;
18703                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18704                                 char *idx_2=NULL;
18705                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18706                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18707                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18708                                         free(idx_2);
18709                                 }
18710                         }
18711                         ndr->depth--;
18712                 }
18713                 ndr->depth--;
18714                 ndr->depth--;
18715                 ndr_print_ptr(ndr, "needed", r->out.needed);
18716                 ndr->depth++;
18717                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18718                 ndr->depth--;
18719                 ndr_print_WERROR(ndr, "result", r->out.result);
18720                 ndr->depth--;
18721         }
18722         ndr->depth--;
18723 }
18724
18725 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18726 {
18727         if (flags & NDR_IN) {
18728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18729                 if (r->in.printername) {
18730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18734                 }
18735                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18736                 if (r->in.datatype) {
18737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18740                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18741                 }
18742                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18743                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18744         }
18745         if (flags & NDR_OUT) {
18746                 if (r->out.handle == NULL) {
18747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18748                 }
18749                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18750                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18751         }
18752         return NDR_ERR_SUCCESS;
18753 }
18754
18755 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18756 {
18757         uint32_t _ptr_printername;
18758         uint32_t _ptr_datatype;
18759         TALLOC_CTX *_mem_save_printername_0;
18760         TALLOC_CTX *_mem_save_datatype_0;
18761         TALLOC_CTX *_mem_save_handle_0;
18762         if (flags & NDR_IN) {
18763                 ZERO_STRUCT(r->out);
18764
18765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18766                 if (_ptr_printername) {
18767                         NDR_PULL_ALLOC(ndr, r->in.printername);
18768                 } else {
18769                         r->in.printername = NULL;
18770                 }
18771                 if (r->in.printername) {
18772                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18776                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18777                                 return 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));
18778                         }
18779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18782                 }
18783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18784                 if (_ptr_datatype) {
18785                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18786                 } else {
18787                         r->in.datatype = NULL;
18788                 }
18789                 if (r->in.datatype) {
18790                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18791                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18794                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18795                                 return 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));
18796                         }
18797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18800                 }
18801                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18802                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18803                 NDR_PULL_ALLOC(ndr, r->out.handle);
18804                 ZERO_STRUCTP(r->out.handle);
18805         }
18806         if (flags & NDR_OUT) {
18807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18808                         NDR_PULL_ALLOC(ndr, r->out.handle);
18809                 }
18810                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18811                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18812                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18815         }
18816         return NDR_ERR_SUCCESS;
18817 }
18818
18819 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18820 {
18821         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18822         ndr->depth++;
18823         if (flags & NDR_SET_VALUES) {
18824                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18825         }
18826         if (flags & NDR_IN) {
18827                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18828                 ndr->depth++;
18829                 ndr_print_ptr(ndr, "printername", r->in.printername);
18830                 ndr->depth++;
18831                 if (r->in.printername) {
18832                         ndr_print_string(ndr, "printername", r->in.printername);
18833                 }
18834                 ndr->depth--;
18835                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18836                 ndr->depth++;
18837                 if (r->in.datatype) {
18838                         ndr_print_string(ndr, "datatype", r->in.datatype);
18839                 }
18840                 ndr->depth--;
18841                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18842                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18843                 ndr->depth--;
18844         }
18845         if (flags & NDR_OUT) {
18846                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18847                 ndr->depth++;
18848                 ndr_print_ptr(ndr, "handle", r->out.handle);
18849                 ndr->depth++;
18850                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18851                 ndr->depth--;
18852                 ndr_print_WERROR(ndr, "result", r->out.result);
18853                 ndr->depth--;
18854         }
18855         ndr->depth--;
18856 }
18857
18858 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18859 {
18860         if (flags & NDR_IN) {
18861                 if (r->in.handle == NULL) {
18862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18863                 }
18864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18867                 if (r->in.ctr) {
18868                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18869                 }
18870                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18871         }
18872         if (flags & NDR_OUT) {
18873                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18874         }
18875         return NDR_ERR_SUCCESS;
18876 }
18877
18878 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18879 {
18880         uint32_t _ptr_ctr;
18881         TALLOC_CTX *_mem_save_handle_0;
18882         TALLOC_CTX *_mem_save_ctr_0;
18883         if (flags & NDR_IN) {
18884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18885                         NDR_PULL_ALLOC(ndr, r->in.handle);
18886                 }
18887                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18893                 if (_ptr_ctr) {
18894                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18895                 } else {
18896                         r->in.ctr = NULL;
18897                 }
18898                 if (r->in.ctr) {
18899                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18900                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18901                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18903                 }
18904                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18905         }
18906         if (flags & NDR_OUT) {
18907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18908         }
18909         return NDR_ERR_SUCCESS;
18910 }
18911
18912 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18913 {
18914         ndr_print_struct(ndr, name, "spoolss_SetJob");
18915         ndr->depth++;
18916         if (flags & NDR_SET_VALUES) {
18917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18918         }
18919         if (flags & NDR_IN) {
18920                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18921                 ndr->depth++;
18922                 ndr_print_ptr(ndr, "handle", r->in.handle);
18923                 ndr->depth++;
18924                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18925                 ndr->depth--;
18926                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18927                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18928                 ndr->depth++;
18929                 if (r->in.ctr) {
18930                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18931                 }
18932                 ndr->depth--;
18933                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18934                 ndr->depth--;
18935         }
18936         if (flags & NDR_OUT) {
18937                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18938                 ndr->depth++;
18939                 ndr_print_WERROR(ndr, "result", r->out.result);
18940                 ndr->depth--;
18941         }
18942         ndr->depth--;
18943 }
18944
18945 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18946 {
18947         if (flags & NDR_IN) {
18948                 if (r->in.handle == NULL) {
18949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18950                 }
18951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18954                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18955                 if (r->in.buffer) {
18956                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18957                 }
18958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18959         }
18960         if (flags & NDR_OUT) {
18961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18962                 if (r->out.info) {
18963                         {
18964                                 struct ndr_push *_ndr_info;
18965                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18966                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18967                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18968                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18969                         }
18970                 }
18971                 if (r->out.needed == NULL) {
18972                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18973                 }
18974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18975                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18976         }
18977         return NDR_ERR_SUCCESS;
18978 }
18979
18980 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18981 {
18982         uint32_t _ptr_buffer;
18983         uint32_t _ptr_info;
18984         TALLOC_CTX *_mem_save_handle_0;
18985         TALLOC_CTX *_mem_save_buffer_0;
18986         TALLOC_CTX *_mem_save_info_0;
18987         TALLOC_CTX *_mem_save_needed_0;
18988         if (flags & NDR_IN) {
18989                 ZERO_STRUCT(r->out);
18990
18991                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18992                         NDR_PULL_ALLOC(ndr, r->in.handle);
18993                 }
18994                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18995                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18996                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19001                 if (_ptr_buffer) {
19002                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19003                 } else {
19004                         r->in.buffer = NULL;
19005                 }
19006                 if (r->in.buffer) {
19007                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19008                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19009                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19011                 }
19012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19013                 NDR_PULL_ALLOC(ndr, r->out.needed);
19014                 ZERO_STRUCTP(r->out.needed);
19015         }
19016         if (flags & NDR_OUT) {
19017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19018                 if (_ptr_info) {
19019                         NDR_PULL_ALLOC(ndr, r->out.info);
19020                 } else {
19021                         r->out.info = NULL;
19022                 }
19023                 if (r->out.info) {
19024                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19025                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19026                         {
19027                                 struct ndr_pull *_ndr_info;
19028                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19029                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19030                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19031                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19032                         }
19033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19034                 }
19035                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19036                         NDR_PULL_ALLOC(ndr, r->out.needed);
19037                 }
19038                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19039                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19041                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19042                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19043         }
19044         return NDR_ERR_SUCCESS;
19045 }
19046
19047 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19048 {
19049         ndr_print_struct(ndr, name, "spoolss_GetJob");
19050         ndr->depth++;
19051         if (flags & NDR_SET_VALUES) {
19052                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19053         }
19054         if (flags & NDR_IN) {
19055                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19056                 ndr->depth++;
19057                 ndr_print_ptr(ndr, "handle", r->in.handle);
19058                 ndr->depth++;
19059                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19060                 ndr->depth--;
19061                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19062                 ndr_print_uint32(ndr, "level", r->in.level);
19063                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19064                 ndr->depth++;
19065                 if (r->in.buffer) {
19066                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19067                 }
19068                 ndr->depth--;
19069                 ndr_print_uint32(ndr, "offered", r->in.offered);
19070                 ndr->depth--;
19071         }
19072         if (flags & NDR_OUT) {
19073                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19074                 ndr->depth++;
19075                 ndr_print_ptr(ndr, "info", r->out.info);
19076                 ndr->depth++;
19077                 if (r->out.info) {
19078                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19079                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19080                 }
19081                 ndr->depth--;
19082                 ndr_print_ptr(ndr, "needed", r->out.needed);
19083                 ndr->depth++;
19084                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19085                 ndr->depth--;
19086                 ndr_print_WERROR(ndr, "result", r->out.result);
19087                 ndr->depth--;
19088         }
19089         ndr->depth--;
19090 }
19091
19092 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19093 {
19094         if (flags & NDR_IN) {
19095                 if (r->in.handle == NULL) {
19096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19097                 }
19098                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19103                 if (r->in.buffer) {
19104                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19105                 }
19106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19107         }
19108         if (flags & NDR_OUT) {
19109                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19110                 if (r->out.info) {
19111                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19112                 }
19113                 if (r->out.needed == NULL) {
19114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19115                 }
19116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19117                 if (r->out.count == NULL) {
19118                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19119                 }
19120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19121                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19122         }
19123         return NDR_ERR_SUCCESS;
19124 }
19125
19126 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19127 {
19128         uint32_t _ptr_buffer;
19129         uint32_t _ptr_info;
19130         TALLOC_CTX *_mem_save_handle_0;
19131         TALLOC_CTX *_mem_save_buffer_0;
19132         TALLOC_CTX *_mem_save_info_0;
19133         TALLOC_CTX *_mem_save_needed_0;
19134         TALLOC_CTX *_mem_save_count_0;
19135         if (flags & NDR_IN) {
19136                 ZERO_STRUCT(r->out);
19137
19138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19139                         NDR_PULL_ALLOC(ndr, r->in.handle);
19140                 }
19141                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19142                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19143                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19146                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19147                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19149                 if (_ptr_buffer) {
19150                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19151                 } else {
19152                         r->in.buffer = NULL;
19153                 }
19154                 if (r->in.buffer) {
19155                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19156                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19157                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19159                 }
19160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19161                 NDR_PULL_ALLOC(ndr, r->out.needed);
19162                 ZERO_STRUCTP(r->out.needed);
19163                 NDR_PULL_ALLOC(ndr, r->out.count);
19164                 ZERO_STRUCTP(r->out.count);
19165         }
19166         if (flags & NDR_OUT) {
19167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19168                 if (_ptr_info) {
19169                         NDR_PULL_ALLOC(ndr, r->out.info);
19170                 } else {
19171                         r->out.info = NULL;
19172                 }
19173                 if (r->out.info) {
19174                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19175                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19176                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19178                 }
19179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19180                         NDR_PULL_ALLOC(ndr, r->out.needed);
19181                 }
19182                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19187                         NDR_PULL_ALLOC(ndr, r->out.count);
19188                 }
19189                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19192                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19193                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19194         }
19195         return NDR_ERR_SUCCESS;
19196 }
19197
19198 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19199 {
19200         uint32_t cntr_info_0;
19201         if (flags & NDR_IN) {
19202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19204         }
19205         if (flags & NDR_OUT) {
19206                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19207                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19208                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19209                 }
19210                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19211                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19212                 }
19213         }
19214         return NDR_ERR_SUCCESS;
19215 }
19216
19217 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19218 {
19219         uint32_t cntr_info_0;
19220         TALLOC_CTX *_mem_save_info_0;
19221         if (flags & NDR_IN) {
19222                 ZERO_STRUCT(r->out);
19223
19224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19226         }
19227         if (flags & NDR_OUT) {
19228                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19229                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19231                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19232                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19233                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19234                 }
19235                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19236                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19237                 }
19238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19239         }
19240         return NDR_ERR_SUCCESS;
19241 }
19242
19243 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19244 {
19245         uint32_t cntr_info_2;
19246         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19247         ndr->depth++;
19248         if (flags & NDR_SET_VALUES) {
19249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19250         }
19251         if (flags & NDR_IN) {
19252                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19253                 ndr->depth++;
19254                 ndr_print_ptr(ndr, "handle", r->in.handle);
19255                 ndr->depth++;
19256                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19257                 ndr->depth--;
19258                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19259                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19260                 ndr_print_uint32(ndr, "level", r->in.level);
19261                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19262                 ndr->depth++;
19263                 if (r->in.buffer) {
19264                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19265                 }
19266                 ndr->depth--;
19267                 ndr_print_uint32(ndr, "offered", r->in.offered);
19268                 ndr->depth--;
19269         }
19270         if (flags & NDR_OUT) {
19271                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19272                 ndr->depth++;
19273                 ndr_print_ptr(ndr, "count", r->out.count);
19274                 ndr->depth++;
19275                 ndr_print_uint32(ndr, "count", *r->out.count);
19276                 ndr->depth--;
19277                 ndr_print_ptr(ndr, "info", r->out.info);
19278                 ndr->depth++;
19279                 ndr_print_ptr(ndr, "info", *r->out.info);
19280                 ndr->depth++;
19281                 if (*r->out.info) {
19282                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19283                         ndr->depth++;
19284                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19285                                 char *idx_2=NULL;
19286                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19287                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19288                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19289                                         free(idx_2);
19290                                 }
19291                         }
19292                         ndr->depth--;
19293                 }
19294                 ndr->depth--;
19295                 ndr->depth--;
19296                 ndr_print_ptr(ndr, "needed", r->out.needed);
19297                 ndr->depth++;
19298                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19299                 ndr->depth--;
19300                 ndr_print_WERROR(ndr, "result", r->out.result);
19301                 ndr->depth--;
19302         }
19303         ndr->depth--;
19304 }
19305
19306 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19307 {
19308         if (flags & NDR_IN) {
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_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19317 {
19318         if (flags & NDR_IN) {
19319         }
19320         if (flags & NDR_OUT) {
19321                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19322         }
19323         return NDR_ERR_SUCCESS;
19324 }
19325
19326 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19327 {
19328         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19329         ndr->depth++;
19330         if (flags & NDR_SET_VALUES) {
19331                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19332         }
19333         if (flags & NDR_IN) {
19334                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19335                 ndr->depth++;
19336                 ndr->depth--;
19337         }
19338         if (flags & NDR_OUT) {
19339                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19340                 ndr->depth++;
19341                 ndr_print_WERROR(ndr, "result", r->out.result);
19342                 ndr->depth--;
19343         }
19344         ndr->depth--;
19345 }
19346
19347 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19348 {
19349         if (flags & NDR_IN) {
19350                 if (r->in.handle == NULL) {
19351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19352                 }
19353                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19354         }
19355         if (flags & NDR_OUT) {
19356                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19357         }
19358         return NDR_ERR_SUCCESS;
19359 }
19360
19361 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19362 {
19363         TALLOC_CTX *_mem_save_handle_0;
19364         if (flags & NDR_IN) {
19365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19366                         NDR_PULL_ALLOC(ndr, r->in.handle);
19367                 }
19368                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19372         }
19373         if (flags & NDR_OUT) {
19374                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19375         }
19376         return NDR_ERR_SUCCESS;
19377 }
19378
19379 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19380 {
19381         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19382         ndr->depth++;
19383         if (flags & NDR_SET_VALUES) {
19384                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19385         }
19386         if (flags & NDR_IN) {
19387                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19388                 ndr->depth++;
19389                 ndr_print_ptr(ndr, "handle", r->in.handle);
19390                 ndr->depth++;
19391                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19392                 ndr->depth--;
19393                 ndr->depth--;
19394         }
19395         if (flags & NDR_OUT) {
19396                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19397                 ndr->depth++;
19398                 ndr_print_WERROR(ndr, "result", r->out.result);
19399                 ndr->depth--;
19400         }
19401         ndr->depth--;
19402 }
19403
19404 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19405 {
19406         if (flags & NDR_IN) {
19407                 if (r->in.handle == NULL) {
19408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19409                 }
19410                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19411                 if (r->in.info_ctr == NULL) {
19412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19413                 }
19414                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19415                 if (r->in.devmode_ctr == NULL) {
19416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19417                 }
19418                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19419                 if (r->in.secdesc_ctr == NULL) {
19420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19421                 }
19422                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19423                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19424         }
19425         if (flags & NDR_OUT) {
19426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19427         }
19428         return NDR_ERR_SUCCESS;
19429 }
19430
19431 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19432 {
19433         TALLOC_CTX *_mem_save_handle_0;
19434         TALLOC_CTX *_mem_save_info_ctr_0;
19435         TALLOC_CTX *_mem_save_devmode_ctr_0;
19436         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19437         if (flags & NDR_IN) {
19438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19439                         NDR_PULL_ALLOC(ndr, r->in.handle);
19440                 }
19441                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19442                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19443                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19446                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19447                 }
19448                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19449                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19450                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19453                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19454                 }
19455                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19457                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19459                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19460                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19461                 }
19462                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19463                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19464                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19465                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19466                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19467         }
19468         if (flags & NDR_OUT) {
19469                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19470         }
19471         return NDR_ERR_SUCCESS;
19472 }
19473
19474 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19475 {
19476         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19477         ndr->depth++;
19478         if (flags & NDR_SET_VALUES) {
19479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19480         }
19481         if (flags & NDR_IN) {
19482                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19483                 ndr->depth++;
19484                 ndr_print_ptr(ndr, "handle", r->in.handle);
19485                 ndr->depth++;
19486                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19487                 ndr->depth--;
19488                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19489                 ndr->depth++;
19490                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19491                 ndr->depth--;
19492                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19493                 ndr->depth++;
19494                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19495                 ndr->depth--;
19496                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19497                 ndr->depth++;
19498                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19499                 ndr->depth--;
19500                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19501                 ndr->depth--;
19502         }
19503         if (flags & NDR_OUT) {
19504                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19505                 ndr->depth++;
19506                 ndr_print_WERROR(ndr, "result", r->out.result);
19507                 ndr->depth--;
19508         }
19509         ndr->depth--;
19510 }
19511
19512 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19513 {
19514         if (flags & NDR_IN) {
19515                 if (r->in.handle == NULL) {
19516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19517                 }
19518                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19521                 if (r->in.buffer) {
19522                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19523                 }
19524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19525         }
19526         if (flags & NDR_OUT) {
19527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19528                 if (r->out.info) {
19529                         {
19530                                 struct ndr_push *_ndr_info;
19531                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19532                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19533                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19534                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19535                         }
19536                 }
19537                 if (r->out.needed == NULL) {
19538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19539                 }
19540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19541                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19542         }
19543         return NDR_ERR_SUCCESS;
19544 }
19545
19546 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19547 {
19548         uint32_t _ptr_buffer;
19549         uint32_t _ptr_info;
19550         TALLOC_CTX *_mem_save_handle_0;
19551         TALLOC_CTX *_mem_save_buffer_0;
19552         TALLOC_CTX *_mem_save_info_0;
19553         TALLOC_CTX *_mem_save_needed_0;
19554         if (flags & NDR_IN) {
19555                 ZERO_STRUCT(r->out);
19556
19557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19558                         NDR_PULL_ALLOC(ndr, r->in.handle);
19559                 }
19560                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19566                 if (_ptr_buffer) {
19567                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19568                 } else {
19569                         r->in.buffer = NULL;
19570                 }
19571                 if (r->in.buffer) {
19572                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19573                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19574                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19575                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19576                 }
19577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19578                 NDR_PULL_ALLOC(ndr, r->out.needed);
19579                 ZERO_STRUCTP(r->out.needed);
19580         }
19581         if (flags & NDR_OUT) {
19582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19583                 if (_ptr_info) {
19584                         NDR_PULL_ALLOC(ndr, r->out.info);
19585                 } else {
19586                         r->out.info = NULL;
19587                 }
19588                 if (r->out.info) {
19589                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19590                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19591                         {
19592                                 struct ndr_pull *_ndr_info;
19593                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19594                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19595                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19596                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19597                         }
19598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19599                 }
19600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19601                         NDR_PULL_ALLOC(ndr, r->out.needed);
19602                 }
19603                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19608         }
19609         return NDR_ERR_SUCCESS;
19610 }
19611
19612 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19613 {
19614         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19615         ndr->depth++;
19616         if (flags & NDR_SET_VALUES) {
19617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19618         }
19619         if (flags & NDR_IN) {
19620                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19621                 ndr->depth++;
19622                 ndr_print_ptr(ndr, "handle", r->in.handle);
19623                 ndr->depth++;
19624                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19625                 ndr->depth--;
19626                 ndr_print_uint32(ndr, "level", r->in.level);
19627                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19628                 ndr->depth++;
19629                 if (r->in.buffer) {
19630                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19631                 }
19632                 ndr->depth--;
19633                 ndr_print_uint32(ndr, "offered", r->in.offered);
19634                 ndr->depth--;
19635         }
19636         if (flags & NDR_OUT) {
19637                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19638                 ndr->depth++;
19639                 ndr_print_ptr(ndr, "info", r->out.info);
19640                 ndr->depth++;
19641                 if (r->out.info) {
19642                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19643                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19644                 }
19645                 ndr->depth--;
19646                 ndr_print_ptr(ndr, "needed", r->out.needed);
19647                 ndr->depth++;
19648                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19649                 ndr->depth--;
19650                 ndr_print_WERROR(ndr, "result", r->out.result);
19651                 ndr->depth--;
19652         }
19653         ndr->depth--;
19654 }
19655
19656 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19657 {
19658         if (flags & NDR_IN) {
19659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19660                 if (r->in.servername) {
19661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19665                 }
19666                 if (r->in.info_ctr == NULL) {
19667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19668                 }
19669                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19670         }
19671         if (flags & NDR_OUT) {
19672                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19673         }
19674         return NDR_ERR_SUCCESS;
19675 }
19676
19677 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19678 {
19679         uint32_t _ptr_servername;
19680         TALLOC_CTX *_mem_save_servername_0;
19681         TALLOC_CTX *_mem_save_info_ctr_0;
19682         if (flags & NDR_IN) {
19683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19684                 if (_ptr_servername) {
19685                         NDR_PULL_ALLOC(ndr, r->in.servername);
19686                 } else {
19687                         r->in.servername = NULL;
19688                 }
19689                 if (r->in.servername) {
19690                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19691                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19694                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19695                                 return 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));
19696                         }
19697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19700                 }
19701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19702                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19703                 }
19704                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19705                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19706                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19708         }
19709         if (flags & NDR_OUT) {
19710                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19711         }
19712         return NDR_ERR_SUCCESS;
19713 }
19714
19715 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19716 {
19717         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19718         ndr->depth++;
19719         if (flags & NDR_SET_VALUES) {
19720                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19721         }
19722         if (flags & NDR_IN) {
19723                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19724                 ndr->depth++;
19725                 ndr_print_ptr(ndr, "servername", r->in.servername);
19726                 ndr->depth++;
19727                 if (r->in.servername) {
19728                         ndr_print_string(ndr, "servername", r->in.servername);
19729                 }
19730                 ndr->depth--;
19731                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19732                 ndr->depth++;
19733                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19734                 ndr->depth--;
19735                 ndr->depth--;
19736         }
19737         if (flags & NDR_OUT) {
19738                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19739                 ndr->depth++;
19740                 ndr_print_WERROR(ndr, "result", r->out.result);
19741                 ndr->depth--;
19742         }
19743         ndr->depth--;
19744 }
19745
19746 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19747 {
19748         if (flags & NDR_IN) {
19749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19750                 if (r->in.server) {
19751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19755                 }
19756                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19757                 if (r->in.environment) {
19758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19762                 }
19763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19764                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19765                 if (r->in.buffer) {
19766                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19767                 }
19768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19769         }
19770         if (flags & NDR_OUT) {
19771                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19772                 if (r->out.info) {
19773                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19774                 }
19775                 if (r->out.needed == NULL) {
19776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19777                 }
19778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19779                 if (r->out.count == NULL) {
19780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19781                 }
19782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19783                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19784         }
19785         return NDR_ERR_SUCCESS;
19786 }
19787
19788 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19789 {
19790         uint32_t _ptr_server;
19791         uint32_t _ptr_environment;
19792         uint32_t _ptr_buffer;
19793         uint32_t _ptr_info;
19794         TALLOC_CTX *_mem_save_server_0;
19795         TALLOC_CTX *_mem_save_environment_0;
19796         TALLOC_CTX *_mem_save_buffer_0;
19797         TALLOC_CTX *_mem_save_info_0;
19798         TALLOC_CTX *_mem_save_needed_0;
19799         TALLOC_CTX *_mem_save_count_0;
19800         if (flags & NDR_IN) {
19801                 ZERO_STRUCT(r->out);
19802
19803                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19804                 if (_ptr_server) {
19805                         NDR_PULL_ALLOC(ndr, r->in.server);
19806                 } else {
19807                         r->in.server = NULL;
19808                 }
19809                 if (r->in.server) {
19810                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19811                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19812                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19813                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19814                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19815                                 return 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));
19816                         }
19817                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19818                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19820                 }
19821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19822                 if (_ptr_environment) {
19823                         NDR_PULL_ALLOC(ndr, r->in.environment);
19824                 } else {
19825                         r->in.environment = NULL;
19826                 }
19827                 if (r->in.environment) {
19828                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19829                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19832                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19833                                 return 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));
19834                         }
19835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19838                 }
19839                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19841                 if (_ptr_buffer) {
19842                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19843                 } else {
19844                         r->in.buffer = NULL;
19845                 }
19846                 if (r->in.buffer) {
19847                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19848                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19849                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19851                 }
19852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19853                 NDR_PULL_ALLOC(ndr, r->out.needed);
19854                 ZERO_STRUCTP(r->out.needed);
19855                 NDR_PULL_ALLOC(ndr, r->out.count);
19856                 ZERO_STRUCTP(r->out.count);
19857         }
19858         if (flags & NDR_OUT) {
19859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19860                 if (_ptr_info) {
19861                         NDR_PULL_ALLOC(ndr, r->out.info);
19862                 } else {
19863                         r->out.info = NULL;
19864                 }
19865                 if (r->out.info) {
19866                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19867                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19868                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19870                 }
19871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19872                         NDR_PULL_ALLOC(ndr, r->out.needed);
19873                 }
19874                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19878                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19879                         NDR_PULL_ALLOC(ndr, r->out.count);
19880                 }
19881                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19882                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19886         }
19887         return NDR_ERR_SUCCESS;
19888 }
19889
19890 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19891 {
19892         uint32_t cntr_info_0;
19893         if (flags & NDR_IN) {
19894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19896         }
19897         if (flags & NDR_OUT) {
19898                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19899                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19900                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19901                 }
19902                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19903                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19904                 }
19905         }
19906         return NDR_ERR_SUCCESS;
19907 }
19908
19909 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19910 {
19911         uint32_t cntr_info_0;
19912         TALLOC_CTX *_mem_save_info_0;
19913         if (flags & NDR_IN) {
19914                 ZERO_STRUCT(r->out);
19915
19916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19918         }
19919         if (flags & NDR_OUT) {
19920                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19921                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19922                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19923                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19924                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19925                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19926                 }
19927                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19928                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19929                 }
19930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19931         }
19932         return NDR_ERR_SUCCESS;
19933 }
19934
19935 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19936 {
19937         uint32_t cntr_info_2;
19938         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19939         ndr->depth++;
19940         if (flags & NDR_SET_VALUES) {
19941                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19942         }
19943         if (flags & NDR_IN) {
19944                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19945                 ndr->depth++;
19946                 ndr_print_ptr(ndr, "server", r->in.server);
19947                 ndr->depth++;
19948                 if (r->in.server) {
19949                         ndr_print_string(ndr, "server", r->in.server);
19950                 }
19951                 ndr->depth--;
19952                 ndr_print_ptr(ndr, "environment", r->in.environment);
19953                 ndr->depth++;
19954                 if (r->in.environment) {
19955                         ndr_print_string(ndr, "environment", r->in.environment);
19956                 }
19957                 ndr->depth--;
19958                 ndr_print_uint32(ndr, "level", r->in.level);
19959                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19960                 ndr->depth++;
19961                 if (r->in.buffer) {
19962                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19963                 }
19964                 ndr->depth--;
19965                 ndr_print_uint32(ndr, "offered", r->in.offered);
19966                 ndr->depth--;
19967         }
19968         if (flags & NDR_OUT) {
19969                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19970                 ndr->depth++;
19971                 ndr_print_ptr(ndr, "count", r->out.count);
19972                 ndr->depth++;
19973                 ndr_print_uint32(ndr, "count", *r->out.count);
19974                 ndr->depth--;
19975                 ndr_print_ptr(ndr, "info", r->out.info);
19976                 ndr->depth++;
19977                 ndr_print_ptr(ndr, "info", *r->out.info);
19978                 ndr->depth++;
19979                 if (*r->out.info) {
19980                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19981                         ndr->depth++;
19982                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19983                                 char *idx_2=NULL;
19984                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19985                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19986                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19987                                         free(idx_2);
19988                                 }
19989                         }
19990                         ndr->depth--;
19991                 }
19992                 ndr->depth--;
19993                 ndr->depth--;
19994                 ndr_print_ptr(ndr, "needed", r->out.needed);
19995                 ndr->depth++;
19996                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19997                 ndr->depth--;
19998                 ndr_print_WERROR(ndr, "result", r->out.result);
19999                 ndr->depth--;
20000         }
20001         ndr->depth--;
20002 }
20003
20004 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20005 {
20006         if (flags & NDR_IN) {
20007         }
20008         if (flags & NDR_OUT) {
20009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20010         }
20011         return NDR_ERR_SUCCESS;
20012 }
20013
20014 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20015 {
20016         if (flags & NDR_IN) {
20017         }
20018         if (flags & NDR_OUT) {
20019                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20020         }
20021         return NDR_ERR_SUCCESS;
20022 }
20023
20024 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20025 {
20026         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20027         ndr->depth++;
20028         if (flags & NDR_SET_VALUES) {
20029                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20030         }
20031         if (flags & NDR_IN) {
20032                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20033                 ndr->depth++;
20034                 ndr->depth--;
20035         }
20036         if (flags & NDR_OUT) {
20037                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20038                 ndr->depth++;
20039                 ndr_print_WERROR(ndr, "result", r->out.result);
20040                 ndr->depth--;
20041         }
20042         ndr->depth--;
20043 }
20044
20045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20046 {
20047         if (flags & NDR_IN) {
20048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20049                 if (r->in.server) {
20050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20054                 }
20055                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20056                 if (r->in.environment) {
20057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20060                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20061                 }
20062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20064                 if (r->in.buffer) {
20065                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20066                 }
20067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20068         }
20069         if (flags & NDR_OUT) {
20070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20071                 if (r->out.info) {
20072                         {
20073                                 struct ndr_push *_ndr_info;
20074                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20075                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20076                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20077                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20078                         }
20079                 }
20080                 if (r->out.needed == NULL) {
20081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20082                 }
20083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20084                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20085         }
20086         return NDR_ERR_SUCCESS;
20087 }
20088
20089 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20090 {
20091         uint32_t _ptr_server;
20092         uint32_t _ptr_environment;
20093         uint32_t _ptr_buffer;
20094         uint32_t _ptr_info;
20095         TALLOC_CTX *_mem_save_server_0;
20096         TALLOC_CTX *_mem_save_environment_0;
20097         TALLOC_CTX *_mem_save_buffer_0;
20098         TALLOC_CTX *_mem_save_info_0;
20099         TALLOC_CTX *_mem_save_needed_0;
20100         if (flags & NDR_IN) {
20101                 ZERO_STRUCT(r->out);
20102
20103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20104                 if (_ptr_server) {
20105                         NDR_PULL_ALLOC(ndr, r->in.server);
20106                 } else {
20107                         r->in.server = NULL;
20108                 }
20109                 if (r->in.server) {
20110                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20111                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20112                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20113                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20114                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20115                                 return 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));
20116                         }
20117                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20118                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20120                 }
20121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20122                 if (_ptr_environment) {
20123                         NDR_PULL_ALLOC(ndr, r->in.environment);
20124                 } else {
20125                         r->in.environment = NULL;
20126                 }
20127                 if (r->in.environment) {
20128                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20129                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20130                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20131                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20132                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20133                                 return 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));
20134                         }
20135                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20136                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20138                 }
20139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20141                 if (_ptr_buffer) {
20142                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20143                 } else {
20144                         r->in.buffer = NULL;
20145                 }
20146                 if (r->in.buffer) {
20147                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20148                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20149                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20151                 }
20152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20153                 NDR_PULL_ALLOC(ndr, r->out.needed);
20154                 ZERO_STRUCTP(r->out.needed);
20155         }
20156         if (flags & NDR_OUT) {
20157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20158                 if (_ptr_info) {
20159                         NDR_PULL_ALLOC(ndr, r->out.info);
20160                 } else {
20161                         r->out.info = NULL;
20162                 }
20163                 if (r->out.info) {
20164                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20165                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20166                         {
20167                                 struct ndr_pull *_ndr_info;
20168                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20169                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20170                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20171                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20172                         }
20173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20174                 }
20175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20176                         NDR_PULL_ALLOC(ndr, r->out.needed);
20177                 }
20178                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20179                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20182                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20183         }
20184         return NDR_ERR_SUCCESS;
20185 }
20186
20187 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20188 {
20189         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20190         ndr->depth++;
20191         if (flags & NDR_SET_VALUES) {
20192                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20193         }
20194         if (flags & NDR_IN) {
20195                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20196                 ndr->depth++;
20197                 ndr_print_ptr(ndr, "server", r->in.server);
20198                 ndr->depth++;
20199                 if (r->in.server) {
20200                         ndr_print_string(ndr, "server", r->in.server);
20201                 }
20202                 ndr->depth--;
20203                 ndr_print_ptr(ndr, "environment", r->in.environment);
20204                 ndr->depth++;
20205                 if (r->in.environment) {
20206                         ndr_print_string(ndr, "environment", r->in.environment);
20207                 }
20208                 ndr->depth--;
20209                 ndr_print_uint32(ndr, "level", r->in.level);
20210                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20211                 ndr->depth++;
20212                 if (r->in.buffer) {
20213                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20214                 }
20215                 ndr->depth--;
20216                 ndr_print_uint32(ndr, "offered", r->in.offered);
20217                 ndr->depth--;
20218         }
20219         if (flags & NDR_OUT) {
20220                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20221                 ndr->depth++;
20222                 ndr_print_ptr(ndr, "info", r->out.info);
20223                 ndr->depth++;
20224                 if (r->out.info) {
20225                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20226                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20227                 }
20228                 ndr->depth--;
20229                 ndr_print_ptr(ndr, "needed", r->out.needed);
20230                 ndr->depth++;
20231                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20232                 ndr->depth--;
20233                 ndr_print_WERROR(ndr, "result", r->out.result);
20234                 ndr->depth--;
20235         }
20236         ndr->depth--;
20237 }
20238
20239 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20240 {
20241         if (flags & NDR_IN) {
20242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20243                 if (r->in.server) {
20244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20246                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20247                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20248                 }
20249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20256                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20257         }
20258         if (flags & NDR_OUT) {
20259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20260         }
20261         return NDR_ERR_SUCCESS;
20262 }
20263
20264 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20265 {
20266         uint32_t _ptr_server;
20267         TALLOC_CTX *_mem_save_server_0;
20268         if (flags & NDR_IN) {
20269                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20270                 if (_ptr_server) {
20271                         NDR_PULL_ALLOC(ndr, r->in.server);
20272                 } else {
20273                         r->in.server = NULL;
20274                 }
20275                 if (r->in.server) {
20276                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20277                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20278                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20279                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20280                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20281                                 return 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));
20282                         }
20283                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20284                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20286                 }
20287                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20288                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20289                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20290                         return 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));
20291                 }
20292                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20293                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20294                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20295                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20296                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20297                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.driver), ndr_get_array_length(ndr, &r->in.driver));
20298                 }
20299                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20300                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20301         }
20302         if (flags & NDR_OUT) {
20303                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20304         }
20305         return NDR_ERR_SUCCESS;
20306 }
20307
20308 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20309 {
20310         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20311         ndr->depth++;
20312         if (flags & NDR_SET_VALUES) {
20313                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20314         }
20315         if (flags & NDR_IN) {
20316                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20317                 ndr->depth++;
20318                 ndr_print_ptr(ndr, "server", r->in.server);
20319                 ndr->depth++;
20320                 if (r->in.server) {
20321                         ndr_print_string(ndr, "server", r->in.server);
20322                 }
20323                 ndr->depth--;
20324                 ndr_print_string(ndr, "architecture", r->in.architecture);
20325                 ndr_print_string(ndr, "driver", r->in.driver);
20326                 ndr->depth--;
20327         }
20328         if (flags & NDR_OUT) {
20329                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20330                 ndr->depth++;
20331                 ndr_print_WERROR(ndr, "result", r->out.result);
20332                 ndr->depth--;
20333         }
20334         ndr->depth--;
20335 }
20336
20337 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20338 {
20339         if (flags & NDR_IN) {
20340                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20341                 if (r->in.server) {
20342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20346                 }
20347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20350                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20354                 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));
20355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20358                 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));
20359         }
20360         if (flags & NDR_OUT) {
20361                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20362         }
20363         return NDR_ERR_SUCCESS;
20364 }
20365
20366 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20367 {
20368         uint32_t _ptr_server;
20369         TALLOC_CTX *_mem_save_server_0;
20370         if (flags & NDR_IN) {
20371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20372                 if (_ptr_server) {
20373                         NDR_PULL_ALLOC(ndr, r->in.server);
20374                 } else {
20375                         r->in.server = NULL;
20376                 }
20377                 if (r->in.server) {
20378                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20379                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20381                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20382                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20383                                 return 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));
20384                         }
20385                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20386                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20388                 }
20389                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20390                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20391                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20392                         return 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));
20393                 }
20394                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20395                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20396                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20397                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20398                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20399                         return 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));
20400                 }
20401                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20402                 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));
20403                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20404                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20405                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20406                         return 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));
20407                 }
20408                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20409                 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));
20410         }
20411         if (flags & NDR_OUT) {
20412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20413         }
20414         return NDR_ERR_SUCCESS;
20415 }
20416
20417 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20418 {
20419         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20420         ndr->depth++;
20421         if (flags & NDR_SET_VALUES) {
20422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20423         }
20424         if (flags & NDR_IN) {
20425                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20426                 ndr->depth++;
20427                 ndr_print_ptr(ndr, "server", r->in.server);
20428                 ndr->depth++;
20429                 if (r->in.server) {
20430                         ndr_print_string(ndr, "server", r->in.server);
20431                 }
20432                 ndr->depth--;
20433                 ndr_print_string(ndr, "architecture", r->in.architecture);
20434                 ndr_print_string(ndr, "path_name", r->in.path_name);
20435                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20436                 ndr->depth--;
20437         }
20438         if (flags & NDR_OUT) {
20439                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20440                 ndr->depth++;
20441                 ndr_print_WERROR(ndr, "result", r->out.result);
20442                 ndr->depth--;
20443         }
20444         ndr->depth--;
20445 }
20446
20447 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20448 {
20449         if (flags & NDR_IN) {
20450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20451                 if (r->in.servername) {
20452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20456                 }
20457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20458                 if (r->in.environment) {
20459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20463                 }
20464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20465                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20466                 if (r->in.buffer) {
20467                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20468                 }
20469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20470         }
20471         if (flags & NDR_OUT) {
20472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20473                 if (r->out.info) {
20474                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20475                 }
20476                 if (r->out.needed == NULL) {
20477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20478                 }
20479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20480                 if (r->out.count == NULL) {
20481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20482                 }
20483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20484                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20485         }
20486         return NDR_ERR_SUCCESS;
20487 }
20488
20489 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20490 {
20491         uint32_t _ptr_servername;
20492         uint32_t _ptr_environment;
20493         uint32_t _ptr_buffer;
20494         uint32_t _ptr_info;
20495         TALLOC_CTX *_mem_save_servername_0;
20496         TALLOC_CTX *_mem_save_environment_0;
20497         TALLOC_CTX *_mem_save_buffer_0;
20498         TALLOC_CTX *_mem_save_info_0;
20499         TALLOC_CTX *_mem_save_needed_0;
20500         TALLOC_CTX *_mem_save_count_0;
20501         if (flags & NDR_IN) {
20502                 ZERO_STRUCT(r->out);
20503
20504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20505                 if (_ptr_servername) {
20506                         NDR_PULL_ALLOC(ndr, r->in.servername);
20507                 } else {
20508                         r->in.servername = NULL;
20509                 }
20510                 if (r->in.servername) {
20511                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20512                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20515                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20516                                 return 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));
20517                         }
20518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20521                 }
20522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20523                 if (_ptr_environment) {
20524                         NDR_PULL_ALLOC(ndr, r->in.environment);
20525                 } else {
20526                         r->in.environment = NULL;
20527                 }
20528                 if (r->in.environment) {
20529                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20530                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20531                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20532                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20533                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20534                                 return 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));
20535                         }
20536                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20537                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20538                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20539                 }
20540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20542                 if (_ptr_buffer) {
20543                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20544                 } else {
20545                         r->in.buffer = NULL;
20546                 }
20547                 if (r->in.buffer) {
20548                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20550                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20552                 }
20553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20554                 NDR_PULL_ALLOC(ndr, r->out.needed);
20555                 ZERO_STRUCTP(r->out.needed);
20556                 NDR_PULL_ALLOC(ndr, r->out.count);
20557                 ZERO_STRUCTP(r->out.count);
20558         }
20559         if (flags & NDR_OUT) {
20560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20561                 if (_ptr_info) {
20562                         NDR_PULL_ALLOC(ndr, r->out.info);
20563                 } else {
20564                         r->out.info = NULL;
20565                 }
20566                 if (r->out.info) {
20567                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20568                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20569                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20571                 }
20572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20573                         NDR_PULL_ALLOC(ndr, r->out.needed);
20574                 }
20575                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20580                         NDR_PULL_ALLOC(ndr, r->out.count);
20581                 }
20582                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20587         }
20588         return NDR_ERR_SUCCESS;
20589 }
20590
20591 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20592 {
20593         uint32_t cntr_info_0;
20594         if (flags & NDR_IN) {
20595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20597         }
20598         if (flags & NDR_OUT) {
20599                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20600                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20601                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20602                 }
20603                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20604                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20605                 }
20606         }
20607         return NDR_ERR_SUCCESS;
20608 }
20609
20610 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20611 {
20612         uint32_t cntr_info_0;
20613         TALLOC_CTX *_mem_save_info_0;
20614         if (flags & NDR_IN) {
20615                 ZERO_STRUCT(r->out);
20616
20617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20619         }
20620         if (flags & NDR_OUT) {
20621                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20622                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20624                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20625                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20626                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20627                 }
20628                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20629                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20630                 }
20631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20632         }
20633         return NDR_ERR_SUCCESS;
20634 }
20635
20636 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20637 {
20638         uint32_t cntr_info_2;
20639         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20640         ndr->depth++;
20641         if (flags & NDR_SET_VALUES) {
20642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20643         }
20644         if (flags & NDR_IN) {
20645                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20646                 ndr->depth++;
20647                 ndr_print_ptr(ndr, "servername", r->in.servername);
20648                 ndr->depth++;
20649                 if (r->in.servername) {
20650                         ndr_print_string(ndr, "servername", r->in.servername);
20651                 }
20652                 ndr->depth--;
20653                 ndr_print_ptr(ndr, "environment", r->in.environment);
20654                 ndr->depth++;
20655                 if (r->in.environment) {
20656                         ndr_print_string(ndr, "environment", r->in.environment);
20657                 }
20658                 ndr->depth--;
20659                 ndr_print_uint32(ndr, "level", r->in.level);
20660                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20661                 ndr->depth++;
20662                 if (r->in.buffer) {
20663                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20664                 }
20665                 ndr->depth--;
20666                 ndr_print_uint32(ndr, "offered", r->in.offered);
20667                 ndr->depth--;
20668         }
20669         if (flags & NDR_OUT) {
20670                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20671                 ndr->depth++;
20672                 ndr_print_ptr(ndr, "count", r->out.count);
20673                 ndr->depth++;
20674                 ndr_print_uint32(ndr, "count", *r->out.count);
20675                 ndr->depth--;
20676                 ndr_print_ptr(ndr, "info", r->out.info);
20677                 ndr->depth++;
20678                 ndr_print_ptr(ndr, "info", *r->out.info);
20679                 ndr->depth++;
20680                 if (*r->out.info) {
20681                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20682                         ndr->depth++;
20683                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20684                                 char *idx_2=NULL;
20685                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20686                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20687                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20688                                         free(idx_2);
20689                                 }
20690                         }
20691                         ndr->depth--;
20692                 }
20693                 ndr->depth--;
20694                 ndr->depth--;
20695                 ndr_print_ptr(ndr, "needed", r->out.needed);
20696                 ndr->depth++;
20697                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20698                 ndr->depth--;
20699                 ndr_print_WERROR(ndr, "result", r->out.result);
20700                 ndr->depth--;
20701         }
20702         ndr->depth--;
20703 }
20704
20705 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20706 {
20707         if (flags & NDR_IN) {
20708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20709                 if (r->in.server) {
20710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20714                 }
20715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20716                 if (r->in.environment) {
20717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20721                 }
20722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20724                 if (r->in.buffer) {
20725                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20726                 }
20727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20728         }
20729         if (flags & NDR_OUT) {
20730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20731                 if (r->out.info) {
20732                         {
20733                                 struct ndr_push *_ndr_info;
20734                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20735                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20736                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20737                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20738                         }
20739                 }
20740                 if (r->out.needed == NULL) {
20741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20742                 }
20743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20744                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20745         }
20746         return NDR_ERR_SUCCESS;
20747 }
20748
20749 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20750 {
20751         uint32_t _ptr_server;
20752         uint32_t _ptr_environment;
20753         uint32_t _ptr_buffer;
20754         uint32_t _ptr_info;
20755         TALLOC_CTX *_mem_save_server_0;
20756         TALLOC_CTX *_mem_save_environment_0;
20757         TALLOC_CTX *_mem_save_buffer_0;
20758         TALLOC_CTX *_mem_save_info_0;
20759         TALLOC_CTX *_mem_save_needed_0;
20760         if (flags & NDR_IN) {
20761                 ZERO_STRUCT(r->out);
20762
20763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20764                 if (_ptr_server) {
20765                         NDR_PULL_ALLOC(ndr, r->in.server);
20766                 } else {
20767                         r->in.server = NULL;
20768                 }
20769                 if (r->in.server) {
20770                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20771                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20772                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20773                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20774                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20775                                 return 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));
20776                         }
20777                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20778                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20780                 }
20781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20782                 if (_ptr_environment) {
20783                         NDR_PULL_ALLOC(ndr, r->in.environment);
20784                 } else {
20785                         r->in.environment = NULL;
20786                 }
20787                 if (r->in.environment) {
20788                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20789                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20790                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20791                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20792                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20793                                 return 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));
20794                         }
20795                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20796                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20797                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20798                 }
20799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20801                 if (_ptr_buffer) {
20802                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20803                 } else {
20804                         r->in.buffer = NULL;
20805                 }
20806                 if (r->in.buffer) {
20807                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20808                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20809                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20811                 }
20812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20813                 NDR_PULL_ALLOC(ndr, r->out.needed);
20814                 ZERO_STRUCTP(r->out.needed);
20815         }
20816         if (flags & NDR_OUT) {
20817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20818                 if (_ptr_info) {
20819                         NDR_PULL_ALLOC(ndr, r->out.info);
20820                 } else {
20821                         r->out.info = NULL;
20822                 }
20823                 if (r->out.info) {
20824                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20825                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20826                         {
20827                                 struct ndr_pull *_ndr_info;
20828                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20829                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20830                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20831                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20832                         }
20833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20834                 }
20835                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20836                         NDR_PULL_ALLOC(ndr, r->out.needed);
20837                 }
20838                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20839                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20841                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20843         }
20844         return NDR_ERR_SUCCESS;
20845 }
20846
20847 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20848 {
20849         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20850         ndr->depth++;
20851         if (flags & NDR_SET_VALUES) {
20852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20853         }
20854         if (flags & NDR_IN) {
20855                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20856                 ndr->depth++;
20857                 ndr_print_ptr(ndr, "server", r->in.server);
20858                 ndr->depth++;
20859                 if (r->in.server) {
20860                         ndr_print_string(ndr, "server", r->in.server);
20861                 }
20862                 ndr->depth--;
20863                 ndr_print_ptr(ndr, "environment", r->in.environment);
20864                 ndr->depth++;
20865                 if (r->in.environment) {
20866                         ndr_print_string(ndr, "environment", r->in.environment);
20867                 }
20868                 ndr->depth--;
20869                 ndr_print_uint32(ndr, "level", r->in.level);
20870                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20871                 ndr->depth++;
20872                 if (r->in.buffer) {
20873                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20874                 }
20875                 ndr->depth--;
20876                 ndr_print_uint32(ndr, "offered", r->in.offered);
20877                 ndr->depth--;
20878         }
20879         if (flags & NDR_OUT) {
20880                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20881                 ndr->depth++;
20882                 ndr_print_ptr(ndr, "info", r->out.info);
20883                 ndr->depth++;
20884                 if (r->out.info) {
20885                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20886                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20887                 }
20888                 ndr->depth--;
20889                 ndr_print_ptr(ndr, "needed", r->out.needed);
20890                 ndr->depth++;
20891                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20892                 ndr->depth--;
20893                 ndr_print_WERROR(ndr, "result", r->out.result);
20894                 ndr->depth--;
20895         }
20896         ndr->depth--;
20897 }
20898
20899 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20900 {
20901         if (flags & NDR_IN) {
20902                 if (r->in.handle == NULL) {
20903                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20904                 }
20905                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20907                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20908                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20909         }
20910         if (flags & NDR_OUT) {
20911                 if (r->out.job_id == NULL) {
20912                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20913                 }
20914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20915                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20916         }
20917         return NDR_ERR_SUCCESS;
20918 }
20919
20920 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20921 {
20922         TALLOC_CTX *_mem_save_handle_0;
20923         TALLOC_CTX *_mem_save_job_id_0;
20924         if (flags & NDR_IN) {
20925                 ZERO_STRUCT(r->out);
20926
20927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20928                         NDR_PULL_ALLOC(ndr, r->in.handle);
20929                 }
20930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20935                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20936                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20937                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20938                 ZERO_STRUCTP(r->out.job_id);
20939         }
20940         if (flags & NDR_OUT) {
20941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20942                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20943                 }
20944                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20945                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20948                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20949         }
20950         return NDR_ERR_SUCCESS;
20951 }
20952
20953 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20954 {
20955         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20956         ndr->depth++;
20957         if (flags & NDR_SET_VALUES) {
20958                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20959         }
20960         if (flags & NDR_IN) {
20961                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20962                 ndr->depth++;
20963                 ndr_print_ptr(ndr, "handle", r->in.handle);
20964                 ndr->depth++;
20965                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20966                 ndr->depth--;
20967                 ndr_print_uint32(ndr, "level", r->in.level);
20968                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20969                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20970                 ndr->depth--;
20971         }
20972         if (flags & NDR_OUT) {
20973                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20974                 ndr->depth++;
20975                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20976                 ndr->depth++;
20977                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20978                 ndr->depth--;
20979                 ndr_print_WERROR(ndr, "result", r->out.result);
20980                 ndr->depth--;
20981         }
20982         ndr->depth--;
20983 }
20984
20985 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20986 {
20987         if (flags & NDR_IN) {
20988                 if (r->in.handle == NULL) {
20989                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20990                 }
20991                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20992         }
20993         if (flags & NDR_OUT) {
20994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20995         }
20996         return NDR_ERR_SUCCESS;
20997 }
20998
20999 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21000 {
21001         TALLOC_CTX *_mem_save_handle_0;
21002         if (flags & NDR_IN) {
21003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21004                         NDR_PULL_ALLOC(ndr, r->in.handle);
21005                 }
21006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21007                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21010         }
21011         if (flags & NDR_OUT) {
21012                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21013         }
21014         return NDR_ERR_SUCCESS;
21015 }
21016
21017 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21018 {
21019         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21020         ndr->depth++;
21021         if (flags & NDR_SET_VALUES) {
21022                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21023         }
21024         if (flags & NDR_IN) {
21025                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21026                 ndr->depth++;
21027                 ndr_print_ptr(ndr, "handle", r->in.handle);
21028                 ndr->depth++;
21029                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21030                 ndr->depth--;
21031                 ndr->depth--;
21032         }
21033         if (flags & NDR_OUT) {
21034                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21035                 ndr->depth++;
21036                 ndr_print_WERROR(ndr, "result", r->out.result);
21037                 ndr->depth--;
21038         }
21039         ndr->depth--;
21040 }
21041
21042 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21043 {
21044         if (flags & NDR_IN) {
21045                 if (r->in.handle == NULL) {
21046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21047                 }
21048                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21049                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21051         }
21052         if (flags & NDR_OUT) {
21053                 if (r->out.num_written == NULL) {
21054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21055                 }
21056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21057                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21058         }
21059         return NDR_ERR_SUCCESS;
21060 }
21061
21062 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21063 {
21064         TALLOC_CTX *_mem_save_handle_0;
21065         TALLOC_CTX *_mem_save_num_written_0;
21066         if (flags & NDR_IN) {
21067                 ZERO_STRUCT(r->out);
21068
21069                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21070                         NDR_PULL_ALLOC(ndr, r->in.handle);
21071                 }
21072                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21073                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21074                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21075                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21076                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21078                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21079                 ZERO_STRUCTP(r->out.num_written);
21080         }
21081         if (flags & NDR_OUT) {
21082                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21083                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21084                 }
21085                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21086                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21088                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21089                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21090         }
21091         return NDR_ERR_SUCCESS;
21092 }
21093
21094 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21095 {
21096         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21097         ndr->depth++;
21098         if (flags & NDR_SET_VALUES) {
21099                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21100         }
21101         if (flags & NDR_IN) {
21102                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21103                 ndr->depth++;
21104                 ndr_print_ptr(ndr, "handle", r->in.handle);
21105                 ndr->depth++;
21106                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21107                 ndr->depth--;
21108                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21109                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21110                 ndr->depth--;
21111         }
21112         if (flags & NDR_OUT) {
21113                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21114                 ndr->depth++;
21115                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21116                 ndr->depth++;
21117                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21118                 ndr->depth--;
21119                 ndr_print_WERROR(ndr, "result", r->out.result);
21120                 ndr->depth--;
21121         }
21122         ndr->depth--;
21123 }
21124
21125 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21126 {
21127         if (flags & NDR_IN) {
21128                 if (r->in.handle == NULL) {
21129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21130                 }
21131                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21132         }
21133         if (flags & NDR_OUT) {
21134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21135         }
21136         return NDR_ERR_SUCCESS;
21137 }
21138
21139 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21140 {
21141         TALLOC_CTX *_mem_save_handle_0;
21142         if (flags & NDR_IN) {
21143                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21144                         NDR_PULL_ALLOC(ndr, r->in.handle);
21145                 }
21146                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21147                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21148                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21150         }
21151         if (flags & NDR_OUT) {
21152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21153         }
21154         return NDR_ERR_SUCCESS;
21155 }
21156
21157 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21158 {
21159         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21160         ndr->depth++;
21161         if (flags & NDR_SET_VALUES) {
21162                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21163         }
21164         if (flags & NDR_IN) {
21165                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21166                 ndr->depth++;
21167                 ndr_print_ptr(ndr, "handle", r->in.handle);
21168                 ndr->depth++;
21169                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21170                 ndr->depth--;
21171                 ndr->depth--;
21172         }
21173         if (flags & NDR_OUT) {
21174                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21175                 ndr->depth++;
21176                 ndr_print_WERROR(ndr, "result", r->out.result);
21177                 ndr->depth--;
21178         }
21179         ndr->depth--;
21180 }
21181
21182 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21183 {
21184         if (flags & NDR_IN) {
21185                 if (r->in.handle == NULL) {
21186                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21187                 }
21188                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21189         }
21190         if (flags & NDR_OUT) {
21191                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21192         }
21193         return NDR_ERR_SUCCESS;
21194 }
21195
21196 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21197 {
21198         TALLOC_CTX *_mem_save_handle_0;
21199         if (flags & NDR_IN) {
21200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21201                         NDR_PULL_ALLOC(ndr, r->in.handle);
21202                 }
21203                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21204                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21205                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21207         }
21208         if (flags & NDR_OUT) {
21209                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21210         }
21211         return NDR_ERR_SUCCESS;
21212 }
21213
21214 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21215 {
21216         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21217         ndr->depth++;
21218         if (flags & NDR_SET_VALUES) {
21219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21220         }
21221         if (flags & NDR_IN) {
21222                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21223                 ndr->depth++;
21224                 ndr_print_ptr(ndr, "handle", r->in.handle);
21225                 ndr->depth++;
21226                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21227                 ndr->depth--;
21228                 ndr->depth--;
21229         }
21230         if (flags & NDR_OUT) {
21231                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21232                 ndr->depth++;
21233                 ndr_print_WERROR(ndr, "result", r->out.result);
21234                 ndr->depth--;
21235         }
21236         ndr->depth--;
21237 }
21238
21239 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21240 {
21241         if (flags & NDR_IN) {
21242                 if (r->in.handle == NULL) {
21243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21244                 }
21245                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21247         }
21248         if (flags & NDR_OUT) {
21249                 if (r->out.data == NULL) {
21250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21251                 }
21252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21253                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21254                 if (r->out._data_size == NULL) {
21255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21256                 }
21257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21258                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21259         }
21260         return NDR_ERR_SUCCESS;
21261 }
21262
21263 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21264 {
21265         TALLOC_CTX *_mem_save_handle_0;
21266         TALLOC_CTX *_mem_save__data_size_0;
21267         if (flags & NDR_IN) {
21268                 ZERO_STRUCT(r->out);
21269
21270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21271                         NDR_PULL_ALLOC(ndr, r->in.handle);
21272                 }
21273                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21274                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21275                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21278                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21279                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21280                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21281                 ZERO_STRUCTP(r->out._data_size);
21282         }
21283         if (flags & NDR_OUT) {
21284                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21286                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21287                 }
21288                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21290                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21291                 }
21292                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21293                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21297                 if (r->out.data) {
21298                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21299                 }
21300         }
21301         return NDR_ERR_SUCCESS;
21302 }
21303
21304 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21305 {
21306         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21307         ndr->depth++;
21308         if (flags & NDR_SET_VALUES) {
21309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21310         }
21311         if (flags & NDR_IN) {
21312                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21313                 ndr->depth++;
21314                 ndr_print_ptr(ndr, "handle", r->in.handle);
21315                 ndr->depth++;
21316                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21317                 ndr->depth--;
21318                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21319                 ndr->depth--;
21320         }
21321         if (flags & NDR_OUT) {
21322                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21323                 ndr->depth++;
21324                 ndr_print_ptr(ndr, "data", r->out.data);
21325                 ndr->depth++;
21326                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21327                 ndr->depth--;
21328                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21329                 ndr->depth++;
21330                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21331                 ndr->depth--;
21332                 ndr_print_WERROR(ndr, "result", r->out.result);
21333                 ndr->depth--;
21334         }
21335         ndr->depth--;
21336 }
21337
21338 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21339 {
21340         if (flags & NDR_IN) {
21341                 if (r->in.handle == NULL) {
21342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21343                 }
21344                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21345         }
21346         if (flags & NDR_OUT) {
21347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21348         }
21349         return NDR_ERR_SUCCESS;
21350 }
21351
21352 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21353 {
21354         TALLOC_CTX *_mem_save_handle_0;
21355         if (flags & NDR_IN) {
21356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21357                         NDR_PULL_ALLOC(ndr, r->in.handle);
21358                 }
21359                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21360                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21363         }
21364         if (flags & NDR_OUT) {
21365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21366         }
21367         return NDR_ERR_SUCCESS;
21368 }
21369
21370 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21371 {
21372         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21373         ndr->depth++;
21374         if (flags & NDR_SET_VALUES) {
21375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21376         }
21377         if (flags & NDR_IN) {
21378                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21379                 ndr->depth++;
21380                 ndr_print_ptr(ndr, "handle", r->in.handle);
21381                 ndr->depth++;
21382                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21383                 ndr->depth--;
21384                 ndr->depth--;
21385         }
21386         if (flags & NDR_OUT) {
21387                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21388                 ndr->depth++;
21389                 ndr_print_WERROR(ndr, "result", r->out.result);
21390                 ndr->depth--;
21391         }
21392         ndr->depth--;
21393 }
21394
21395 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21396 {
21397         if (flags & NDR_IN) {
21398                 if (r->in.handle == NULL) {
21399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21400                 }
21401                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21404                 if (r->in.buffer) {
21405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21406                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21407                 }
21408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21409         }
21410         if (flags & NDR_OUT) {
21411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21412                 if (r->out.buffer) {
21413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21414                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21415                 }
21416                 if (r->out.needed == NULL) {
21417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21418                 }
21419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21420                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21421         }
21422         return NDR_ERR_SUCCESS;
21423 }
21424
21425 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21426 {
21427         uint32_t _ptr_buffer;
21428         TALLOC_CTX *_mem_save_handle_0;
21429         TALLOC_CTX *_mem_save_buffer_0;
21430         TALLOC_CTX *_mem_save_needed_0;
21431         if (flags & NDR_IN) {
21432                 ZERO_STRUCT(r->out);
21433
21434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21435                         NDR_PULL_ALLOC(ndr, r->in.handle);
21436                 }
21437                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21438                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21439                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21443                 if (_ptr_buffer) {
21444                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21445                 } else {
21446                         r->in.buffer = NULL;
21447                 }
21448                 if (r->in.buffer) {
21449                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21450                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21451                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21452                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21453                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21455                 }
21456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21457                 NDR_PULL_ALLOC(ndr, r->out.needed);
21458                 ZERO_STRUCTP(r->out.needed);
21459                 if (r->in.buffer) {
21460                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21461                 }
21462         }
21463         if (flags & NDR_OUT) {
21464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21465                 if (_ptr_buffer) {
21466                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21467                 } else {
21468                         r->out.buffer = NULL;
21469                 }
21470                 if (r->out.buffer) {
21471                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21472                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21473                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21474                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21475                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21477                 }
21478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21479                         NDR_PULL_ALLOC(ndr, r->out.needed);
21480                 }
21481                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21482                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21486                 if (r->out.buffer) {
21487                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21488                 }
21489         }
21490         return NDR_ERR_SUCCESS;
21491 }
21492
21493 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21494 {
21495         ndr_print_struct(ndr, name, "spoolss_AddJob");
21496         ndr->depth++;
21497         if (flags & NDR_SET_VALUES) {
21498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21499         }
21500         if (flags & NDR_IN) {
21501                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21502                 ndr->depth++;
21503                 ndr_print_ptr(ndr, "handle", r->in.handle);
21504                 ndr->depth++;
21505                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21506                 ndr->depth--;
21507                 ndr_print_uint32(ndr, "level", r->in.level);
21508                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21509                 ndr->depth++;
21510                 if (r->in.buffer) {
21511                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21512                 }
21513                 ndr->depth--;
21514                 ndr_print_uint32(ndr, "offered", r->in.offered);
21515                 ndr->depth--;
21516         }
21517         if (flags & NDR_OUT) {
21518                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21519                 ndr->depth++;
21520                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21521                 ndr->depth++;
21522                 if (r->out.buffer) {
21523                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21524                 }
21525                 ndr->depth--;
21526                 ndr_print_ptr(ndr, "needed", r->out.needed);
21527                 ndr->depth++;
21528                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21529                 ndr->depth--;
21530                 ndr_print_WERROR(ndr, "result", r->out.result);
21531                 ndr->depth--;
21532         }
21533         ndr->depth--;
21534 }
21535
21536 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21537 {
21538         if (flags & NDR_IN) {
21539                 if (r->in.handle == NULL) {
21540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21541                 }
21542                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21544         }
21545         if (flags & NDR_OUT) {
21546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21547         }
21548         return NDR_ERR_SUCCESS;
21549 }
21550
21551 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21552 {
21553         TALLOC_CTX *_mem_save_handle_0;
21554         if (flags & NDR_IN) {
21555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21556                         NDR_PULL_ALLOC(ndr, r->in.handle);
21557                 }
21558                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21559                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21560                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21563         }
21564         if (flags & NDR_OUT) {
21565                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21566         }
21567         return NDR_ERR_SUCCESS;
21568 }
21569
21570 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21571 {
21572         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21573         ndr->depth++;
21574         if (flags & NDR_SET_VALUES) {
21575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21576         }
21577         if (flags & NDR_IN) {
21578                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21579                 ndr->depth++;
21580                 ndr_print_ptr(ndr, "handle", r->in.handle);
21581                 ndr->depth++;
21582                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21583                 ndr->depth--;
21584                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21585                 ndr->depth--;
21586         }
21587         if (flags & NDR_OUT) {
21588                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21589                 ndr->depth++;
21590                 ndr_print_WERROR(ndr, "result", r->out.result);
21591                 ndr->depth--;
21592         }
21593         ndr->depth--;
21594 }
21595
21596 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21597 {
21598         if (flags & NDR_IN) {
21599                 if (r->in.handle == NULL) {
21600                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21601                 }
21602                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21606                 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));
21607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21608         }
21609         if (flags & NDR_OUT) {
21610                 if (r->out.type == NULL) {
21611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21612                 }
21613                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21614                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21615                 if (r->out.needed == NULL) {
21616                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21617                 }
21618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21619                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21620         }
21621         return NDR_ERR_SUCCESS;
21622 }
21623
21624 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21625 {
21626         TALLOC_CTX *_mem_save_handle_0;
21627         TALLOC_CTX *_mem_save_type_0;
21628         TALLOC_CTX *_mem_save_needed_0;
21629         if (flags & NDR_IN) {
21630                 ZERO_STRUCT(r->out);
21631
21632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21633                         NDR_PULL_ALLOC(ndr, r->in.handle);
21634                 }
21635                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21636                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21637                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21639                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21640                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21641                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21642                         return 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));
21643                 }
21644                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21645                 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));
21646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21647                 NDR_PULL_ALLOC(ndr, r->out.type);
21648                 ZERO_STRUCTP(r->out.type);
21649                 NDR_PULL_ALLOC(ndr, r->out.needed);
21650                 ZERO_STRUCTP(r->out.needed);
21651         }
21652         if (flags & NDR_OUT) {
21653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21654                         NDR_PULL_ALLOC(ndr, r->out.type);
21655                 }
21656                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21657                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21658                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21659                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21660                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21661                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21662                         NDR_PULL_ALLOC(ndr, r->out.needed);
21663                 }
21664                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21665                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21668                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21669         }
21670         return NDR_ERR_SUCCESS;
21671 }
21672
21673 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21674 {
21675         if (flags & NDR_IN) {
21676                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21677         }
21678         if (flags & NDR_OUT) {
21679                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21680                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21681         }
21682         return NDR_ERR_SUCCESS;
21683 }
21684
21685 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21686 {
21687         if (flags & NDR_IN) {
21688                 ZERO_STRUCT(r->out);
21689
21690                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21691         }
21692         if (flags & NDR_OUT) {
21693                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21694                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21695         }
21696         return NDR_ERR_SUCCESS;
21697 }
21698
21699 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21700 {
21701         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21702         ndr->depth++;
21703         if (flags & NDR_SET_VALUES) {
21704                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21705         }
21706         if (flags & NDR_IN) {
21707                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21708                 ndr->depth++;
21709                 ndr_print_ptr(ndr, "handle", r->in.handle);
21710                 ndr->depth++;
21711                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21712                 ndr->depth--;
21713                 ndr_print_string(ndr, "value_name", r->in.value_name);
21714                 ndr_print_uint32(ndr, "offered", r->in.offered);
21715                 ndr->depth--;
21716         }
21717         if (flags & NDR_OUT) {
21718                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21719                 ndr->depth++;
21720                 ndr_print_ptr(ndr, "type", r->out.type);
21721                 ndr->depth++;
21722                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21723                 ndr->depth--;
21724                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21725                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21726                 ndr_print_ptr(ndr, "needed", r->out.needed);
21727                 ndr->depth++;
21728                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21729                 ndr->depth--;
21730                 ndr_print_WERROR(ndr, "result", r->out.result);
21731                 ndr->depth--;
21732         }
21733         ndr->depth--;
21734 }
21735
21736 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21737 {
21738         if (flags & NDR_IN) {
21739                 if (r->in.handle == NULL) {
21740                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21741                 }
21742                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21746                 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));
21747                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21748                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21750         }
21751         if (flags & NDR_OUT) {
21752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21753         }
21754         return NDR_ERR_SUCCESS;
21755 }
21756
21757 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21758 {
21759         if (flags & NDR_IN) {
21760                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21761         }
21762         if (flags & NDR_OUT) {
21763                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21764                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21765         }
21766         return NDR_ERR_SUCCESS;
21767 }
21768
21769 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21770 {
21771         TALLOC_CTX *_mem_save_handle_0;
21772         if (flags & NDR_IN) {
21773                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21774                         NDR_PULL_ALLOC(ndr, r->in.handle);
21775                 }
21776                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21777                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21778                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21779                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21780                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21781                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21782                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21783                         return 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));
21784                 }
21785                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21786                 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));
21787                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21788                 {
21789                         struct ndr_pull *_ndr_data;
21790                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21791                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21792                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21793                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21794                 }
21795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21796         }
21797         if (flags & NDR_OUT) {
21798                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21799         }
21800         return NDR_ERR_SUCCESS;
21801 }
21802
21803 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21804 {
21805         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21806         ndr->depth++;
21807         if (flags & NDR_SET_VALUES) {
21808                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21809         }
21810         if (flags & NDR_IN) {
21811                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21812                 ndr->depth++;
21813                 ndr_print_ptr(ndr, "handle", r->in.handle);
21814                 ndr->depth++;
21815                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21816                 ndr->depth--;
21817                 ndr_print_string(ndr, "value_name", r->in.value_name);
21818                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21819                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21820                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21821                 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);
21822                 ndr->depth--;
21823         }
21824         if (flags & NDR_OUT) {
21825                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21826                 ndr->depth++;
21827                 ndr_print_WERROR(ndr, "result", r->out.result);
21828                 ndr->depth--;
21829         }
21830         ndr->depth--;
21831 }
21832
21833 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21834 {
21835         if (flags & NDR_IN) {
21836         }
21837         if (flags & NDR_OUT) {
21838                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21839         }
21840         return NDR_ERR_SUCCESS;
21841 }
21842
21843 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21844 {
21845         if (flags & NDR_IN) {
21846         }
21847         if (flags & NDR_OUT) {
21848                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21849         }
21850         return NDR_ERR_SUCCESS;
21851 }
21852
21853 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21854 {
21855         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21856         ndr->depth++;
21857         if (flags & NDR_SET_VALUES) {
21858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21859         }
21860         if (flags & NDR_IN) {
21861                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21862                 ndr->depth++;
21863                 ndr->depth--;
21864         }
21865         if (flags & NDR_OUT) {
21866                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21867                 ndr->depth++;
21868                 ndr_print_WERROR(ndr, "result", r->out.result);
21869                 ndr->depth--;
21870         }
21871         ndr->depth--;
21872 }
21873
21874 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21875 {
21876         if (flags & NDR_IN) {
21877                 if (r->in.handle == NULL) {
21878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21879                 }
21880                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21881         }
21882         if (flags & NDR_OUT) {
21883                 if (r->out.handle == NULL) {
21884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21885                 }
21886                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21888         }
21889         return NDR_ERR_SUCCESS;
21890 }
21891
21892 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21893 {
21894         TALLOC_CTX *_mem_save_handle_0;
21895         if (flags & NDR_IN) {
21896                 ZERO_STRUCT(r->out);
21897
21898                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21899                         NDR_PULL_ALLOC(ndr, r->in.handle);
21900                 }
21901                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21902                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21903                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21904                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21905                 NDR_PULL_ALLOC(ndr, r->out.handle);
21906                 *r->out.handle = *r->in.handle;
21907         }
21908         if (flags & NDR_OUT) {
21909                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21910                         NDR_PULL_ALLOC(ndr, r->out.handle);
21911                 }
21912                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21913                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21914                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21915                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21916                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21917         }
21918         return NDR_ERR_SUCCESS;
21919 }
21920
21921 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21922 {
21923         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21924         ndr->depth++;
21925         if (flags & NDR_SET_VALUES) {
21926                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21927         }
21928         if (flags & NDR_IN) {
21929                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21930                 ndr->depth++;
21931                 ndr_print_ptr(ndr, "handle", r->in.handle);
21932                 ndr->depth++;
21933                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21934                 ndr->depth--;
21935                 ndr->depth--;
21936         }
21937         if (flags & NDR_OUT) {
21938                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21939                 ndr->depth++;
21940                 ndr_print_ptr(ndr, "handle", r->out.handle);
21941                 ndr->depth++;
21942                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21943                 ndr->depth--;
21944                 ndr_print_WERROR(ndr, "result", r->out.result);
21945                 ndr->depth--;
21946         }
21947         ndr->depth--;
21948 }
21949
21950 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21951 {
21952         if (flags & NDR_IN) {
21953                 if (r->in.handle == NULL) {
21954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21955                 }
21956                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21958                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21959                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21960         }
21961         if (flags & NDR_OUT) {
21962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21963         }
21964         return NDR_ERR_SUCCESS;
21965 }
21966
21967 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21968 {
21969         TALLOC_CTX *_mem_save_handle_0;
21970         if (flags & NDR_IN) {
21971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21972                         NDR_PULL_ALLOC(ndr, r->in.handle);
21973                 }
21974                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21975                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21976                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21977                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21979                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21980                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21981         }
21982         if (flags & NDR_OUT) {
21983                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21984         }
21985         return NDR_ERR_SUCCESS;
21986 }
21987
21988 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21989 {
21990         ndr_print_struct(ndr, name, "spoolss_AddForm");
21991         ndr->depth++;
21992         if (flags & NDR_SET_VALUES) {
21993                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21994         }
21995         if (flags & NDR_IN) {
21996                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21997                 ndr->depth++;
21998                 ndr_print_ptr(ndr, "handle", r->in.handle);
21999                 ndr->depth++;
22000                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22001                 ndr->depth--;
22002                 ndr_print_uint32(ndr, "level", r->in.level);
22003                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22004                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22005                 ndr->depth--;
22006         }
22007         if (flags & NDR_OUT) {
22008                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22009                 ndr->depth++;
22010                 ndr_print_WERROR(ndr, "result", r->out.result);
22011                 ndr->depth--;
22012         }
22013         ndr->depth--;
22014 }
22015
22016 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22017 {
22018         if (flags & NDR_IN) {
22019                 if (r->in.handle == NULL) {
22020                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22021                 }
22022                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22026                 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));
22027         }
22028         if (flags & NDR_OUT) {
22029                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22030         }
22031         return NDR_ERR_SUCCESS;
22032 }
22033
22034 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22035 {
22036         TALLOC_CTX *_mem_save_handle_0;
22037         if (flags & NDR_IN) {
22038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22039                         NDR_PULL_ALLOC(ndr, r->in.handle);
22040                 }
22041                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22042                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22043                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22045                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22046                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22047                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22048                         return 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));
22049                 }
22050                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22051                 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));
22052         }
22053         if (flags & NDR_OUT) {
22054                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22055         }
22056         return NDR_ERR_SUCCESS;
22057 }
22058
22059 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22060 {
22061         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22062         ndr->depth++;
22063         if (flags & NDR_SET_VALUES) {
22064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22065         }
22066         if (flags & NDR_IN) {
22067                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22068                 ndr->depth++;
22069                 ndr_print_ptr(ndr, "handle", r->in.handle);
22070                 ndr->depth++;
22071                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22072                 ndr->depth--;
22073                 ndr_print_string(ndr, "form_name", r->in.form_name);
22074                 ndr->depth--;
22075         }
22076         if (flags & NDR_OUT) {
22077                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22078                 ndr->depth++;
22079                 ndr_print_WERROR(ndr, "result", r->out.result);
22080                 ndr->depth--;
22081         }
22082         ndr->depth--;
22083 }
22084
22085 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22086 {
22087         if (flags & NDR_IN) {
22088                 if (r->in.handle == NULL) {
22089                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22090                 }
22091                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22095                 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));
22096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22098                 if (r->in.buffer) {
22099                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22100                 }
22101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22102         }
22103         if (flags & NDR_OUT) {
22104                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22105                 if (r->out.info) {
22106                         {
22107                                 struct ndr_push *_ndr_info;
22108                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22109                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22110                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22111                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22112                         }
22113                 }
22114                 if (r->out.needed == NULL) {
22115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22116                 }
22117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22119         }
22120         return NDR_ERR_SUCCESS;
22121 }
22122
22123 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22124 {
22125         uint32_t _ptr_buffer;
22126         uint32_t _ptr_info;
22127         TALLOC_CTX *_mem_save_handle_0;
22128         TALLOC_CTX *_mem_save_buffer_0;
22129         TALLOC_CTX *_mem_save_info_0;
22130         TALLOC_CTX *_mem_save_needed_0;
22131         if (flags & NDR_IN) {
22132                 ZERO_STRUCT(r->out);
22133
22134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22135                         NDR_PULL_ALLOC(ndr, r->in.handle);
22136                 }
22137                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22139                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22141                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22142                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22143                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22144                         return 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));
22145                 }
22146                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22147                 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));
22148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22150                 if (_ptr_buffer) {
22151                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22152                 } else {
22153                         r->in.buffer = NULL;
22154                 }
22155                 if (r->in.buffer) {
22156                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22157                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22158                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22160                 }
22161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22162                 NDR_PULL_ALLOC(ndr, r->out.needed);
22163                 ZERO_STRUCTP(r->out.needed);
22164         }
22165         if (flags & NDR_OUT) {
22166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22167                 if (_ptr_info) {
22168                         NDR_PULL_ALLOC(ndr, r->out.info);
22169                 } else {
22170                         r->out.info = NULL;
22171                 }
22172                 if (r->out.info) {
22173                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22174                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22175                         {
22176                                 struct ndr_pull *_ndr_info;
22177                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22178                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22179                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22180                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22181                         }
22182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22183                 }
22184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22185                         NDR_PULL_ALLOC(ndr, r->out.needed);
22186                 }
22187                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22188                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22191                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22192         }
22193         return NDR_ERR_SUCCESS;
22194 }
22195
22196 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22197 {
22198         ndr_print_struct(ndr, name, "spoolss_GetForm");
22199         ndr->depth++;
22200         if (flags & NDR_SET_VALUES) {
22201                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22202         }
22203         if (flags & NDR_IN) {
22204                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22205                 ndr->depth++;
22206                 ndr_print_ptr(ndr, "handle", r->in.handle);
22207                 ndr->depth++;
22208                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22209                 ndr->depth--;
22210                 ndr_print_string(ndr, "form_name", r->in.form_name);
22211                 ndr_print_uint32(ndr, "level", r->in.level);
22212                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22213                 ndr->depth++;
22214                 if (r->in.buffer) {
22215                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22216                 }
22217                 ndr->depth--;
22218                 ndr_print_uint32(ndr, "offered", r->in.offered);
22219                 ndr->depth--;
22220         }
22221         if (flags & NDR_OUT) {
22222                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22223                 ndr->depth++;
22224                 ndr_print_ptr(ndr, "info", r->out.info);
22225                 ndr->depth++;
22226                 if (r->out.info) {
22227                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22228                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22229                 }
22230                 ndr->depth--;
22231                 ndr_print_ptr(ndr, "needed", r->out.needed);
22232                 ndr->depth++;
22233                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22234                 ndr->depth--;
22235                 ndr_print_WERROR(ndr, "result", r->out.result);
22236                 ndr->depth--;
22237         }
22238         ndr->depth--;
22239 }
22240
22241 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22242 {
22243         if (flags & NDR_IN) {
22244                 if (r->in.handle == NULL) {
22245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22246                 }
22247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22251                 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));
22252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22253                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22254                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22255         }
22256         if (flags & NDR_OUT) {
22257                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22258         }
22259         return NDR_ERR_SUCCESS;
22260 }
22261
22262 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22263 {
22264         TALLOC_CTX *_mem_save_handle_0;
22265         if (flags & NDR_IN) {
22266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22267                         NDR_PULL_ALLOC(ndr, r->in.handle);
22268                 }
22269                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22271                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22273                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22274                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22275                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22276                         return 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));
22277                 }
22278                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22279                 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));
22280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22281                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22282                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22283         }
22284         if (flags & NDR_OUT) {
22285                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22286         }
22287         return NDR_ERR_SUCCESS;
22288 }
22289
22290 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22291 {
22292         ndr_print_struct(ndr, name, "spoolss_SetForm");
22293         ndr->depth++;
22294         if (flags & NDR_SET_VALUES) {
22295                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22296         }
22297         if (flags & NDR_IN) {
22298                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22299                 ndr->depth++;
22300                 ndr_print_ptr(ndr, "handle", r->in.handle);
22301                 ndr->depth++;
22302                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22303                 ndr->depth--;
22304                 ndr_print_string(ndr, "form_name", r->in.form_name);
22305                 ndr_print_uint32(ndr, "level", r->in.level);
22306                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22307                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22308                 ndr->depth--;
22309         }
22310         if (flags & NDR_OUT) {
22311                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22312                 ndr->depth++;
22313                 ndr_print_WERROR(ndr, "result", r->out.result);
22314                 ndr->depth--;
22315         }
22316         ndr->depth--;
22317 }
22318
22319 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22320 {
22321         if (flags & NDR_IN) {
22322                 if (r->in.handle == NULL) {
22323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22324                 }
22325                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22328                 if (r->in.buffer) {
22329                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22330                 }
22331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22332         }
22333         if (flags & NDR_OUT) {
22334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22335                 if (r->out.info) {
22336                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22337                 }
22338                 if (r->out.needed == NULL) {
22339                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22340                 }
22341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22342                 if (r->out.count == NULL) {
22343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22344                 }
22345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22346                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22347         }
22348         return NDR_ERR_SUCCESS;
22349 }
22350
22351 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22352 {
22353         uint32_t _ptr_buffer;
22354         uint32_t _ptr_info;
22355         TALLOC_CTX *_mem_save_handle_0;
22356         TALLOC_CTX *_mem_save_buffer_0;
22357         TALLOC_CTX *_mem_save_info_0;
22358         TALLOC_CTX *_mem_save_needed_0;
22359         TALLOC_CTX *_mem_save_count_0;
22360         if (flags & NDR_IN) {
22361                 ZERO_STRUCT(r->out);
22362
22363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22364                         NDR_PULL_ALLOC(ndr, r->in.handle);
22365                 }
22366                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22372                 if (_ptr_buffer) {
22373                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22374                 } else {
22375                         r->in.buffer = NULL;
22376                 }
22377                 if (r->in.buffer) {
22378                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22379                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22380                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22382                 }
22383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22384                 NDR_PULL_ALLOC(ndr, r->out.needed);
22385                 ZERO_STRUCTP(r->out.needed);
22386                 NDR_PULL_ALLOC(ndr, r->out.count);
22387                 ZERO_STRUCTP(r->out.count);
22388         }
22389         if (flags & NDR_OUT) {
22390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22391                 if (_ptr_info) {
22392                         NDR_PULL_ALLOC(ndr, r->out.info);
22393                 } else {
22394                         r->out.info = NULL;
22395                 }
22396                 if (r->out.info) {
22397                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22398                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22399                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22401                 }
22402                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22403                         NDR_PULL_ALLOC(ndr, r->out.needed);
22404                 }
22405                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22406                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22408                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22410                         NDR_PULL_ALLOC(ndr, r->out.count);
22411                 }
22412                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22413                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22416                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22417         }
22418         return NDR_ERR_SUCCESS;
22419 }
22420
22421 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22422 {
22423         uint32_t cntr_info_0;
22424         if (flags & NDR_IN) {
22425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22427         }
22428         if (flags & NDR_OUT) {
22429                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22430                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22431                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22432                 }
22433                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22434                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22435                 }
22436         }
22437         return NDR_ERR_SUCCESS;
22438 }
22439
22440 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22441 {
22442         uint32_t cntr_info_0;
22443         TALLOC_CTX *_mem_save_info_0;
22444         if (flags & NDR_IN) {
22445                 ZERO_STRUCT(r->out);
22446
22447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22449         }
22450         if (flags & NDR_OUT) {
22451                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22452                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22453                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22454                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22455                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22456                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22457                 }
22458                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22459                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22460                 }
22461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22462         }
22463         return NDR_ERR_SUCCESS;
22464 }
22465
22466 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22467 {
22468         uint32_t cntr_info_2;
22469         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22470         ndr->depth++;
22471         if (flags & NDR_SET_VALUES) {
22472                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22473         }
22474         if (flags & NDR_IN) {
22475                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22476                 ndr->depth++;
22477                 ndr_print_ptr(ndr, "handle", r->in.handle);
22478                 ndr->depth++;
22479                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22480                 ndr->depth--;
22481                 ndr_print_uint32(ndr, "level", r->in.level);
22482                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22483                 ndr->depth++;
22484                 if (r->in.buffer) {
22485                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22486                 }
22487                 ndr->depth--;
22488                 ndr_print_uint32(ndr, "offered", r->in.offered);
22489                 ndr->depth--;
22490         }
22491         if (flags & NDR_OUT) {
22492                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22493                 ndr->depth++;
22494                 ndr_print_ptr(ndr, "count", r->out.count);
22495                 ndr->depth++;
22496                 ndr_print_uint32(ndr, "count", *r->out.count);
22497                 ndr->depth--;
22498                 ndr_print_ptr(ndr, "info", r->out.info);
22499                 ndr->depth++;
22500                 ndr_print_ptr(ndr, "info", *r->out.info);
22501                 ndr->depth++;
22502                 if (*r->out.info) {
22503                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22504                         ndr->depth++;
22505                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22506                                 char *idx_2=NULL;
22507                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22508                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22509                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22510                                         free(idx_2);
22511                                 }
22512                         }
22513                         ndr->depth--;
22514                 }
22515                 ndr->depth--;
22516                 ndr->depth--;
22517                 ndr_print_ptr(ndr, "needed", r->out.needed);
22518                 ndr->depth++;
22519                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22520                 ndr->depth--;
22521                 ndr_print_WERROR(ndr, "result", r->out.result);
22522                 ndr->depth--;
22523         }
22524         ndr->depth--;
22525 }
22526
22527 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22528 {
22529         if (flags & NDR_IN) {
22530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22531                 if (r->in.servername) {
22532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22536                 }
22537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22539                 if (r->in.buffer) {
22540                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22541                 }
22542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22543         }
22544         if (flags & NDR_OUT) {
22545                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22546                 if (r->out.info) {
22547                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22548                 }
22549                 if (r->out.needed == NULL) {
22550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22551                 }
22552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22553                 if (r->out.count == NULL) {
22554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22555                 }
22556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22557                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22558         }
22559         return NDR_ERR_SUCCESS;
22560 }
22561
22562 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22563 {
22564         uint32_t _ptr_servername;
22565         uint32_t _ptr_buffer;
22566         uint32_t _ptr_info;
22567         TALLOC_CTX *_mem_save_servername_0;
22568         TALLOC_CTX *_mem_save_buffer_0;
22569         TALLOC_CTX *_mem_save_info_0;
22570         TALLOC_CTX *_mem_save_needed_0;
22571         TALLOC_CTX *_mem_save_count_0;
22572         if (flags & NDR_IN) {
22573                 ZERO_STRUCT(r->out);
22574
22575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22576                 if (_ptr_servername) {
22577                         NDR_PULL_ALLOC(ndr, r->in.servername);
22578                 } else {
22579                         r->in.servername = NULL;
22580                 }
22581                 if (r->in.servername) {
22582                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22583                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22586                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22587                                 return 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));
22588                         }
22589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22592                 }
22593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22594                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22595                 if (_ptr_buffer) {
22596                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22597                 } else {
22598                         r->in.buffer = NULL;
22599                 }
22600                 if (r->in.buffer) {
22601                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22602                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22603                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22604                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22605                 }
22606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22607                 NDR_PULL_ALLOC(ndr, r->out.needed);
22608                 ZERO_STRUCTP(r->out.needed);
22609                 NDR_PULL_ALLOC(ndr, r->out.count);
22610                 ZERO_STRUCTP(r->out.count);
22611         }
22612         if (flags & NDR_OUT) {
22613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22614                 if (_ptr_info) {
22615                         NDR_PULL_ALLOC(ndr, r->out.info);
22616                 } else {
22617                         r->out.info = NULL;
22618                 }
22619                 if (r->out.info) {
22620                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22621                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22622                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22624                 }
22625                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22626                         NDR_PULL_ALLOC(ndr, r->out.needed);
22627                 }
22628                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22629                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22630                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22633                         NDR_PULL_ALLOC(ndr, r->out.count);
22634                 }
22635                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22636                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22639                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22640         }
22641         return NDR_ERR_SUCCESS;
22642 }
22643
22644 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22645 {
22646         uint32_t cntr_info_0;
22647         if (flags & NDR_IN) {
22648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22650         }
22651         if (flags & NDR_OUT) {
22652                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22653                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22654                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22655                 }
22656                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22657                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22658                 }
22659         }
22660         return NDR_ERR_SUCCESS;
22661 }
22662
22663 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22664 {
22665         uint32_t cntr_info_0;
22666         TALLOC_CTX *_mem_save_info_0;
22667         if (flags & NDR_IN) {
22668                 ZERO_STRUCT(r->out);
22669
22670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22672         }
22673         if (flags & NDR_OUT) {
22674                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22675                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22676                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22677                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22678                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22679                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22680                 }
22681                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22682                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22683                 }
22684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22685         }
22686         return NDR_ERR_SUCCESS;
22687 }
22688
22689 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22690 {
22691         uint32_t cntr_info_2;
22692         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22693         ndr->depth++;
22694         if (flags & NDR_SET_VALUES) {
22695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22696         }
22697         if (flags & NDR_IN) {
22698                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22699                 ndr->depth++;
22700                 ndr_print_ptr(ndr, "servername", r->in.servername);
22701                 ndr->depth++;
22702                 if (r->in.servername) {
22703                         ndr_print_string(ndr, "servername", r->in.servername);
22704                 }
22705                 ndr->depth--;
22706                 ndr_print_uint32(ndr, "level", r->in.level);
22707                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22708                 ndr->depth++;
22709                 if (r->in.buffer) {
22710                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22711                 }
22712                 ndr->depth--;
22713                 ndr_print_uint32(ndr, "offered", r->in.offered);
22714                 ndr->depth--;
22715         }
22716         if (flags & NDR_OUT) {
22717                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22718                 ndr->depth++;
22719                 ndr_print_ptr(ndr, "count", r->out.count);
22720                 ndr->depth++;
22721                 ndr_print_uint32(ndr, "count", *r->out.count);
22722                 ndr->depth--;
22723                 ndr_print_ptr(ndr, "info", r->out.info);
22724                 ndr->depth++;
22725                 ndr_print_ptr(ndr, "info", *r->out.info);
22726                 ndr->depth++;
22727                 if (*r->out.info) {
22728                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22729                         ndr->depth++;
22730                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22731                                 char *idx_2=NULL;
22732                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22733                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22734                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22735                                         free(idx_2);
22736                                 }
22737                         }
22738                         ndr->depth--;
22739                 }
22740                 ndr->depth--;
22741                 ndr->depth--;
22742                 ndr_print_ptr(ndr, "needed", r->out.needed);
22743                 ndr->depth++;
22744                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22745                 ndr->depth--;
22746                 ndr_print_WERROR(ndr, "result", r->out.result);
22747                 ndr->depth--;
22748         }
22749         ndr->depth--;
22750 }
22751
22752 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22753 {
22754         if (flags & NDR_IN) {
22755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22756                 if (r->in.servername) {
22757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22761                 }
22762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22764                 if (r->in.buffer) {
22765                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22766                 }
22767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22768         }
22769         if (flags & NDR_OUT) {
22770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22771                 if (r->out.info) {
22772                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22773                 }
22774                 if (r->out.needed == NULL) {
22775                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22776                 }
22777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22778                 if (r->out.count == NULL) {
22779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22780                 }
22781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22782                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22783         }
22784         return NDR_ERR_SUCCESS;
22785 }
22786
22787 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22788 {
22789         uint32_t _ptr_servername;
22790         uint32_t _ptr_buffer;
22791         uint32_t _ptr_info;
22792         TALLOC_CTX *_mem_save_servername_0;
22793         TALLOC_CTX *_mem_save_buffer_0;
22794         TALLOC_CTX *_mem_save_info_0;
22795         TALLOC_CTX *_mem_save_needed_0;
22796         TALLOC_CTX *_mem_save_count_0;
22797         if (flags & NDR_IN) {
22798                 ZERO_STRUCT(r->out);
22799
22800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22801                 if (_ptr_servername) {
22802                         NDR_PULL_ALLOC(ndr, r->in.servername);
22803                 } else {
22804                         r->in.servername = NULL;
22805                 }
22806                 if (r->in.servername) {
22807                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22808                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22809                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22810                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22811                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22812                                 return 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));
22813                         }
22814                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22815                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22817                 }
22818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22820                 if (_ptr_buffer) {
22821                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22822                 } else {
22823                         r->in.buffer = NULL;
22824                 }
22825                 if (r->in.buffer) {
22826                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22827                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22828                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22830                 }
22831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22832                 NDR_PULL_ALLOC(ndr, r->out.needed);
22833                 ZERO_STRUCTP(r->out.needed);
22834                 NDR_PULL_ALLOC(ndr, r->out.count);
22835                 ZERO_STRUCTP(r->out.count);
22836         }
22837         if (flags & NDR_OUT) {
22838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22839                 if (_ptr_info) {
22840                         NDR_PULL_ALLOC(ndr, r->out.info);
22841                 } else {
22842                         r->out.info = NULL;
22843                 }
22844                 if (r->out.info) {
22845                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22846                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22847                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22849                 }
22850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22851                         NDR_PULL_ALLOC(ndr, r->out.needed);
22852                 }
22853                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22854                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22857                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22858                         NDR_PULL_ALLOC(ndr, r->out.count);
22859                 }
22860                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22861                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22865         }
22866         return NDR_ERR_SUCCESS;
22867 }
22868
22869 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22870 {
22871         uint32_t cntr_info_0;
22872         if (flags & NDR_IN) {
22873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22875         }
22876         if (flags & NDR_OUT) {
22877                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22878                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22879                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22880                 }
22881                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22882                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22883                 }
22884         }
22885         return NDR_ERR_SUCCESS;
22886 }
22887
22888 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22889 {
22890         uint32_t cntr_info_0;
22891         TALLOC_CTX *_mem_save_info_0;
22892         if (flags & NDR_IN) {
22893                 ZERO_STRUCT(r->out);
22894
22895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22897         }
22898         if (flags & NDR_OUT) {
22899                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22900                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22901                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22902                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22903                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22904                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22905                 }
22906                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22907                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22908                 }
22909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22910         }
22911         return NDR_ERR_SUCCESS;
22912 }
22913
22914 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22915 {
22916         uint32_t cntr_info_2;
22917         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22918         ndr->depth++;
22919         if (flags & NDR_SET_VALUES) {
22920                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22921         }
22922         if (flags & NDR_IN) {
22923                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22924                 ndr->depth++;
22925                 ndr_print_ptr(ndr, "servername", r->in.servername);
22926                 ndr->depth++;
22927                 if (r->in.servername) {
22928                         ndr_print_string(ndr, "servername", r->in.servername);
22929                 }
22930                 ndr->depth--;
22931                 ndr_print_uint32(ndr, "level", r->in.level);
22932                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22933                 ndr->depth++;
22934                 if (r->in.buffer) {
22935                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22936                 }
22937                 ndr->depth--;
22938                 ndr_print_uint32(ndr, "offered", r->in.offered);
22939                 ndr->depth--;
22940         }
22941         if (flags & NDR_OUT) {
22942                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22943                 ndr->depth++;
22944                 ndr_print_ptr(ndr, "count", r->out.count);
22945                 ndr->depth++;
22946                 ndr_print_uint32(ndr, "count", *r->out.count);
22947                 ndr->depth--;
22948                 ndr_print_ptr(ndr, "info", r->out.info);
22949                 ndr->depth++;
22950                 ndr_print_ptr(ndr, "info", *r->out.info);
22951                 ndr->depth++;
22952                 if (*r->out.info) {
22953                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22954                         ndr->depth++;
22955                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22956                                 char *idx_2=NULL;
22957                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22958                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22959                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22960                                         free(idx_2);
22961                                 }
22962                         }
22963                         ndr->depth--;
22964                 }
22965                 ndr->depth--;
22966                 ndr->depth--;
22967                 ndr_print_ptr(ndr, "needed", r->out.needed);
22968                 ndr->depth++;
22969                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22970                 ndr->depth--;
22971                 ndr_print_WERROR(ndr, "result", r->out.result);
22972                 ndr->depth--;
22973         }
22974         ndr->depth--;
22975 }
22976
22977 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22978 {
22979         if (flags & NDR_IN) {
22980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22981                 if (r->in.server_name) {
22982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22985                         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));
22986                 }
22987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22991                 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));
22992         }
22993         if (flags & NDR_OUT) {
22994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22995         }
22996         return NDR_ERR_SUCCESS;
22997 }
22998
22999 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23000 {
23001         uint32_t _ptr_server_name;
23002         TALLOC_CTX *_mem_save_server_name_0;
23003         if (flags & NDR_IN) {
23004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23005                 if (_ptr_server_name) {
23006                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23007                 } else {
23008                         r->in.server_name = NULL;
23009                 }
23010                 if (r->in.server_name) {
23011                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23012                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23013                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23014                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23015                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23016                                 return 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));
23017                         }
23018                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23019                         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));
23020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23021                 }
23022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23023                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23024                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23025                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23026                         return 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));
23027                 }
23028                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23029                 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));
23030         }
23031         if (flags & NDR_OUT) {
23032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23033         }
23034         return NDR_ERR_SUCCESS;
23035 }
23036
23037 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23038 {
23039         ndr_print_struct(ndr, name, "spoolss_AddPort");
23040         ndr->depth++;
23041         if (flags & NDR_SET_VALUES) {
23042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23043         }
23044         if (flags & NDR_IN) {
23045                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23046                 ndr->depth++;
23047                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23048                 ndr->depth++;
23049                 if (r->in.server_name) {
23050                         ndr_print_string(ndr, "server_name", r->in.server_name);
23051                 }
23052                 ndr->depth--;
23053                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23054                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23055                 ndr->depth--;
23056         }
23057         if (flags & NDR_OUT) {
23058                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23059                 ndr->depth++;
23060                 ndr_print_WERROR(ndr, "result", r->out.result);
23061                 ndr->depth--;
23062         }
23063         ndr->depth--;
23064 }
23065
23066 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23067 {
23068         if (flags & NDR_IN) {
23069         }
23070         if (flags & NDR_OUT) {
23071                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23072         }
23073         return NDR_ERR_SUCCESS;
23074 }
23075
23076 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23077 {
23078         if (flags & NDR_IN) {
23079         }
23080         if (flags & NDR_OUT) {
23081                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23082         }
23083         return NDR_ERR_SUCCESS;
23084 }
23085
23086 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23087 {
23088         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23089         ndr->depth++;
23090         if (flags & NDR_SET_VALUES) {
23091                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23092         }
23093         if (flags & NDR_IN) {
23094                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23095                 ndr->depth++;
23096                 ndr->depth--;
23097         }
23098         if (flags & NDR_OUT) {
23099                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23100                 ndr->depth++;
23101                 ndr_print_WERROR(ndr, "result", r->out.result);
23102                 ndr->depth--;
23103         }
23104         ndr->depth--;
23105 }
23106
23107 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23108 {
23109         if (flags & NDR_IN) {
23110         }
23111         if (flags & NDR_OUT) {
23112                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23113         }
23114         return NDR_ERR_SUCCESS;
23115 }
23116
23117 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23118 {
23119         if (flags & NDR_IN) {
23120         }
23121         if (flags & NDR_OUT) {
23122                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23123         }
23124         return NDR_ERR_SUCCESS;
23125 }
23126
23127 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23128 {
23129         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23130         ndr->depth++;
23131         if (flags & NDR_SET_VALUES) {
23132                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23133         }
23134         if (flags & NDR_IN) {
23135                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23136                 ndr->depth++;
23137                 ndr->depth--;
23138         }
23139         if (flags & NDR_OUT) {
23140                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23141                 ndr->depth++;
23142                 ndr_print_WERROR(ndr, "result", r->out.result);
23143                 ndr->depth--;
23144         }
23145         ndr->depth--;
23146 }
23147
23148 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23149 {
23150         if (flags & NDR_IN) {
23151         }
23152         if (flags & NDR_OUT) {
23153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23154         }
23155         return NDR_ERR_SUCCESS;
23156 }
23157
23158 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23159 {
23160         if (flags & NDR_IN) {
23161         }
23162         if (flags & NDR_OUT) {
23163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23164         }
23165         return NDR_ERR_SUCCESS;
23166 }
23167
23168 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23169 {
23170         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23171         ndr->depth++;
23172         if (flags & NDR_SET_VALUES) {
23173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23174         }
23175         if (flags & NDR_IN) {
23176                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23177                 ndr->depth++;
23178                 ndr->depth--;
23179         }
23180         if (flags & NDR_OUT) {
23181                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23182                 ndr->depth++;
23183                 ndr_print_WERROR(ndr, "result", r->out.result);
23184                 ndr->depth--;
23185         }
23186         ndr->depth--;
23187 }
23188
23189 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23190 {
23191         if (flags & NDR_IN) {
23192         }
23193         if (flags & NDR_OUT) {
23194                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23195         }
23196         return NDR_ERR_SUCCESS;
23197 }
23198
23199 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23200 {
23201         if (flags & NDR_IN) {
23202         }
23203         if (flags & NDR_OUT) {
23204                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23205         }
23206         return NDR_ERR_SUCCESS;
23207 }
23208
23209 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23210 {
23211         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23212         ndr->depth++;
23213         if (flags & NDR_SET_VALUES) {
23214                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23215         }
23216         if (flags & NDR_IN) {
23217                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23218                 ndr->depth++;
23219                 ndr->depth--;
23220         }
23221         if (flags & NDR_OUT) {
23222                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23223                 ndr->depth++;
23224                 ndr_print_WERROR(ndr, "result", r->out.result);
23225                 ndr->depth--;
23226         }
23227         ndr->depth--;
23228 }
23229
23230 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23231 {
23232         if (flags & NDR_IN) {
23233         }
23234         if (flags & NDR_OUT) {
23235                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23236         }
23237         return NDR_ERR_SUCCESS;
23238 }
23239
23240 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23241 {
23242         if (flags & NDR_IN) {
23243         }
23244         if (flags & NDR_OUT) {
23245                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23246         }
23247         return NDR_ERR_SUCCESS;
23248 }
23249
23250 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23251 {
23252         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23253         ndr->depth++;
23254         if (flags & NDR_SET_VALUES) {
23255                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23256         }
23257         if (flags & NDR_IN) {
23258                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23259                 ndr->depth++;
23260                 ndr->depth--;
23261         }
23262         if (flags & NDR_OUT) {
23263                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23264                 ndr->depth++;
23265                 ndr_print_WERROR(ndr, "result", r->out.result);
23266                 ndr->depth--;
23267         }
23268         ndr->depth--;
23269 }
23270
23271 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23272 {
23273         if (flags & NDR_IN) {
23274         }
23275         if (flags & NDR_OUT) {
23276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23277         }
23278         return NDR_ERR_SUCCESS;
23279 }
23280
23281 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23282 {
23283         if (flags & NDR_IN) {
23284         }
23285         if (flags & NDR_OUT) {
23286                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23287         }
23288         return NDR_ERR_SUCCESS;
23289 }
23290
23291 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23292 {
23293         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23294         ndr->depth++;
23295         if (flags & NDR_SET_VALUES) {
23296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23297         }
23298         if (flags & NDR_IN) {
23299                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23300                 ndr->depth++;
23301                 ndr->depth--;
23302         }
23303         if (flags & NDR_OUT) {
23304                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23305                 ndr->depth++;
23306                 ndr_print_WERROR(ndr, "result", r->out.result);
23307                 ndr->depth--;
23308         }
23309         ndr->depth--;
23310 }
23311
23312 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23313 {
23314         if (flags & NDR_IN) {
23315         }
23316         if (flags & NDR_OUT) {
23317                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23318         }
23319         return NDR_ERR_SUCCESS;
23320 }
23321
23322 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23323 {
23324         if (flags & NDR_IN) {
23325         }
23326         if (flags & NDR_OUT) {
23327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23328         }
23329         return NDR_ERR_SUCCESS;
23330 }
23331
23332 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23333 {
23334         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23335         ndr->depth++;
23336         if (flags & NDR_SET_VALUES) {
23337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23338         }
23339         if (flags & NDR_IN) {
23340                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23341                 ndr->depth++;
23342                 ndr->depth--;
23343         }
23344         if (flags & NDR_OUT) {
23345                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23346                 ndr->depth++;
23347                 ndr_print_WERROR(ndr, "result", r->out.result);
23348                 ndr->depth--;
23349         }
23350         ndr->depth--;
23351 }
23352
23353 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23354 {
23355         if (flags & NDR_IN) {
23356         }
23357         if (flags & NDR_OUT) {
23358                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23359         }
23360         return NDR_ERR_SUCCESS;
23361 }
23362
23363 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23364 {
23365         if (flags & NDR_IN) {
23366         }
23367         if (flags & NDR_OUT) {
23368                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23369         }
23370         return NDR_ERR_SUCCESS;
23371 }
23372
23373 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23374 {
23375         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23376         ndr->depth++;
23377         if (flags & NDR_SET_VALUES) {
23378                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23379         }
23380         if (flags & NDR_IN) {
23381                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23382                 ndr->depth++;
23383                 ndr->depth--;
23384         }
23385         if (flags & NDR_OUT) {
23386                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23387                 ndr->depth++;
23388                 ndr_print_WERROR(ndr, "result", r->out.result);
23389                 ndr->depth--;
23390         }
23391         ndr->depth--;
23392 }
23393
23394 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23395 {
23396         if (flags & NDR_IN) {
23397         }
23398         if (flags & NDR_OUT) {
23399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23400         }
23401         return NDR_ERR_SUCCESS;
23402 }
23403
23404 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23405 {
23406         if (flags & NDR_IN) {
23407         }
23408         if (flags & NDR_OUT) {
23409                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23410         }
23411         return NDR_ERR_SUCCESS;
23412 }
23413
23414 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23415 {
23416         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23417         ndr->depth++;
23418         if (flags & NDR_SET_VALUES) {
23419                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23420         }
23421         if (flags & NDR_IN) {
23422                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23423                 ndr->depth++;
23424                 ndr->depth--;
23425         }
23426         if (flags & NDR_OUT) {
23427                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23428                 ndr->depth++;
23429                 ndr_print_WERROR(ndr, "result", r->out.result);
23430                 ndr->depth--;
23431         }
23432         ndr->depth--;
23433 }
23434
23435 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23436 {
23437         if (flags & NDR_IN) {
23438         }
23439         if (flags & NDR_OUT) {
23440                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23441         }
23442         return NDR_ERR_SUCCESS;
23443 }
23444
23445 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23446 {
23447         if (flags & NDR_IN) {
23448         }
23449         if (flags & NDR_OUT) {
23450                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23451         }
23452         return NDR_ERR_SUCCESS;
23453 }
23454
23455 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23456 {
23457         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23458         ndr->depth++;
23459         if (flags & NDR_SET_VALUES) {
23460                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23461         }
23462         if (flags & NDR_IN) {
23463                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23464                 ndr->depth++;
23465                 ndr->depth--;
23466         }
23467         if (flags & NDR_OUT) {
23468                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23469                 ndr->depth++;
23470                 ndr_print_WERROR(ndr, "result", r->out.result);
23471                 ndr->depth--;
23472         }
23473         ndr->depth--;
23474 }
23475
23476 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23477 {
23478         if (flags & NDR_IN) {
23479         }
23480         if (flags & NDR_OUT) {
23481                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23482         }
23483         return NDR_ERR_SUCCESS;
23484 }
23485
23486 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23487 {
23488         if (flags & NDR_IN) {
23489         }
23490         if (flags & NDR_OUT) {
23491                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23492         }
23493         return NDR_ERR_SUCCESS;
23494 }
23495
23496 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23497 {
23498         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23499         ndr->depth++;
23500         if (flags & NDR_SET_VALUES) {
23501                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23502         }
23503         if (flags & NDR_IN) {
23504                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23505                 ndr->depth++;
23506                 ndr->depth--;
23507         }
23508         if (flags & NDR_OUT) {
23509                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23510                 ndr->depth++;
23511                 ndr_print_WERROR(ndr, "result", r->out.result);
23512                 ndr->depth--;
23513         }
23514         ndr->depth--;
23515 }
23516
23517 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23518 {
23519         if (flags & NDR_IN) {
23520         }
23521         if (flags & NDR_OUT) {
23522                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23523         }
23524         return NDR_ERR_SUCCESS;
23525 }
23526
23527 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23528 {
23529         if (flags & NDR_IN) {
23530         }
23531         if (flags & NDR_OUT) {
23532                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23533         }
23534         return NDR_ERR_SUCCESS;
23535 }
23536
23537 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23538 {
23539         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23540         ndr->depth++;
23541         if (flags & NDR_SET_VALUES) {
23542                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23543         }
23544         if (flags & NDR_IN) {
23545                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23546                 ndr->depth++;
23547                 ndr->depth--;
23548         }
23549         if (flags & NDR_OUT) {
23550                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23551                 ndr->depth++;
23552                 ndr_print_WERROR(ndr, "result", r->out.result);
23553                 ndr->depth--;
23554         }
23555         ndr->depth--;
23556 }
23557
23558 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23559 {
23560         if (flags & NDR_IN) {
23561         }
23562         if (flags & NDR_OUT) {
23563                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23564         }
23565         return NDR_ERR_SUCCESS;
23566 }
23567
23568 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23569 {
23570         if (flags & NDR_IN) {
23571         }
23572         if (flags & NDR_OUT) {
23573                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23574         }
23575         return NDR_ERR_SUCCESS;
23576 }
23577
23578 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23579 {
23580         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23581         ndr->depth++;
23582         if (flags & NDR_SET_VALUES) {
23583                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23584         }
23585         if (flags & NDR_IN) {
23586                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23587                 ndr->depth++;
23588                 ndr->depth--;
23589         }
23590         if (flags & NDR_OUT) {
23591                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23592                 ndr->depth++;
23593                 ndr_print_WERROR(ndr, "result", r->out.result);
23594                 ndr->depth--;
23595         }
23596         ndr->depth--;
23597 }
23598
23599 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23600 {
23601         if (flags & NDR_IN) {
23602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23603                 if (r->in.servername) {
23604                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23605                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23607                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23608                 }
23609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23610                 if (r->in.print_processor_name) {
23611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23614                         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));
23615                 }
23616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23618                 if (r->in.buffer) {
23619                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23620                 }
23621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23622         }
23623         if (flags & NDR_OUT) {
23624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23625                 if (r->out.info) {
23626                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23627                 }
23628                 if (r->out.needed == NULL) {
23629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23630                 }
23631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23632                 if (r->out.count == NULL) {
23633                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23634                 }
23635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23636                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23637         }
23638         return NDR_ERR_SUCCESS;
23639 }
23640
23641 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23642 {
23643         uint32_t _ptr_servername;
23644         uint32_t _ptr_print_processor_name;
23645         uint32_t _ptr_buffer;
23646         uint32_t _ptr_info;
23647         TALLOC_CTX *_mem_save_servername_0;
23648         TALLOC_CTX *_mem_save_print_processor_name_0;
23649         TALLOC_CTX *_mem_save_buffer_0;
23650         TALLOC_CTX *_mem_save_info_0;
23651         TALLOC_CTX *_mem_save_needed_0;
23652         TALLOC_CTX *_mem_save_count_0;
23653         if (flags & NDR_IN) {
23654                 ZERO_STRUCT(r->out);
23655
23656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23657                 if (_ptr_servername) {
23658                         NDR_PULL_ALLOC(ndr, r->in.servername);
23659                 } else {
23660                         r->in.servername = NULL;
23661                 }
23662                 if (r->in.servername) {
23663                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23667                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23668                                 return 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));
23669                         }
23670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23673                 }
23674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23675                 if (_ptr_print_processor_name) {
23676                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23677                 } else {
23678                         r->in.print_processor_name = NULL;
23679                 }
23680                 if (r->in.print_processor_name) {
23681                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23682                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23685                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23686                                 return 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));
23687                         }
23688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23689                         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));
23690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23691                 }
23692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23694                 if (_ptr_buffer) {
23695                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23696                 } else {
23697                         r->in.buffer = NULL;
23698                 }
23699                 if (r->in.buffer) {
23700                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23701                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23702                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23704                 }
23705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23706                 NDR_PULL_ALLOC(ndr, r->out.needed);
23707                 ZERO_STRUCTP(r->out.needed);
23708                 NDR_PULL_ALLOC(ndr, r->out.count);
23709                 ZERO_STRUCTP(r->out.count);
23710         }
23711         if (flags & NDR_OUT) {
23712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23713                 if (_ptr_info) {
23714                         NDR_PULL_ALLOC(ndr, r->out.info);
23715                 } else {
23716                         r->out.info = NULL;
23717                 }
23718                 if (r->out.info) {
23719                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23720                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23721                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23722                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23723                 }
23724                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23725                         NDR_PULL_ALLOC(ndr, r->out.needed);
23726                 }
23727                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23728                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23730                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23731                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23732                         NDR_PULL_ALLOC(ndr, r->out.count);
23733                 }
23734                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23735                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23739         }
23740         return NDR_ERR_SUCCESS;
23741 }
23742
23743 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23744 {
23745         uint32_t cntr_info_0;
23746         if (flags & NDR_IN) {
23747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23749         }
23750         if (flags & NDR_OUT) {
23751                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23752                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23753                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23754                 }
23755                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23756                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23757                 }
23758         }
23759         return NDR_ERR_SUCCESS;
23760 }
23761
23762 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23763 {
23764         uint32_t cntr_info_0;
23765         TALLOC_CTX *_mem_save_info_0;
23766         if (flags & NDR_IN) {
23767                 ZERO_STRUCT(r->out);
23768
23769                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23771         }
23772         if (flags & NDR_OUT) {
23773                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23774                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23775                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23776                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23777                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23778                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23779                 }
23780                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23781                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23782                 }
23783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23784         }
23785         return NDR_ERR_SUCCESS;
23786 }
23787
23788 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23789 {
23790         uint32_t cntr_info_2;
23791         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23792         ndr->depth++;
23793         if (flags & NDR_SET_VALUES) {
23794                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23795         }
23796         if (flags & NDR_IN) {
23797                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23798                 ndr->depth++;
23799                 ndr_print_ptr(ndr, "servername", r->in.servername);
23800                 ndr->depth++;
23801                 if (r->in.servername) {
23802                         ndr_print_string(ndr, "servername", r->in.servername);
23803                 }
23804                 ndr->depth--;
23805                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23806                 ndr->depth++;
23807                 if (r->in.print_processor_name) {
23808                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23809                 }
23810                 ndr->depth--;
23811                 ndr_print_uint32(ndr, "level", r->in.level);
23812                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23813                 ndr->depth++;
23814                 if (r->in.buffer) {
23815                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23816                 }
23817                 ndr->depth--;
23818                 ndr_print_uint32(ndr, "offered", r->in.offered);
23819                 ndr->depth--;
23820         }
23821         if (flags & NDR_OUT) {
23822                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23823                 ndr->depth++;
23824                 ndr_print_ptr(ndr, "count", r->out.count);
23825                 ndr->depth++;
23826                 ndr_print_uint32(ndr, "count", *r->out.count);
23827                 ndr->depth--;
23828                 ndr_print_ptr(ndr, "info", r->out.info);
23829                 ndr->depth++;
23830                 ndr_print_ptr(ndr, "info", *r->out.info);
23831                 ndr->depth++;
23832                 if (*r->out.info) {
23833                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23834                         ndr->depth++;
23835                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23836                                 char *idx_2=NULL;
23837                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23838                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23839                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23840                                         free(idx_2);
23841                                 }
23842                         }
23843                         ndr->depth--;
23844                 }
23845                 ndr->depth--;
23846                 ndr->depth--;
23847                 ndr_print_ptr(ndr, "needed", r->out.needed);
23848                 ndr->depth++;
23849                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23850                 ndr->depth--;
23851                 ndr_print_WERROR(ndr, "result", r->out.result);
23852                 ndr->depth--;
23853         }
23854         ndr->depth--;
23855 }
23856
23857 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23858 {
23859         if (flags & NDR_IN) {
23860                 if (r->in.handle == NULL) {
23861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23862                 }
23863                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23864                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23865                 if (r->in.data_type) {
23866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23867                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23869                         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));
23870                 }
23871                 if (r->in.devmode_ctr == NULL) {
23872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23873                 }
23874                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23875         }
23876         if (flags & NDR_OUT) {
23877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23878         }
23879         return NDR_ERR_SUCCESS;
23880 }
23881
23882 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23883 {
23884         uint32_t _ptr_data_type;
23885         TALLOC_CTX *_mem_save_handle_0;
23886         TALLOC_CTX *_mem_save_data_type_0;
23887         TALLOC_CTX *_mem_save_devmode_ctr_0;
23888         if (flags & NDR_IN) {
23889                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23890                         NDR_PULL_ALLOC(ndr, r->in.handle);
23891                 }
23892                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23893                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23894                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23895                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23897                 if (_ptr_data_type) {
23898                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23899                 } else {
23900                         r->in.data_type = NULL;
23901                 }
23902                 if (r->in.data_type) {
23903                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23904                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23905                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23906                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23907                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23908                                 return 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));
23909                         }
23910                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23911                         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));
23912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23913                 }
23914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23915                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23916                 }
23917                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23919                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23921         }
23922         if (flags & NDR_OUT) {
23923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23924         }
23925         return NDR_ERR_SUCCESS;
23926 }
23927
23928 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23929 {
23930         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23931         ndr->depth++;
23932         if (flags & NDR_SET_VALUES) {
23933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23934         }
23935         if (flags & NDR_IN) {
23936                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23937                 ndr->depth++;
23938                 ndr_print_ptr(ndr, "handle", r->in.handle);
23939                 ndr->depth++;
23940                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23941                 ndr->depth--;
23942                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23943                 ndr->depth++;
23944                 if (r->in.data_type) {
23945                         ndr_print_string(ndr, "data_type", r->in.data_type);
23946                 }
23947                 ndr->depth--;
23948                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23949                 ndr->depth++;
23950                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23951                 ndr->depth--;
23952                 ndr->depth--;
23953         }
23954         if (flags & NDR_OUT) {
23955                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23956                 ndr->depth++;
23957                 ndr_print_WERROR(ndr, "result", r->out.result);
23958                 ndr->depth--;
23959         }
23960         ndr->depth--;
23961 }
23962
23963 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23964 {
23965         if (flags & NDR_IN) {
23966                 if (r->in.handle == NULL) {
23967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23968                 }
23969                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23971                 if (r->in.architecture) {
23972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23976                 }
23977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23979                 if (r->in.buffer) {
23980                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23981                 }
23982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23985         }
23986         if (flags & NDR_OUT) {
23987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23988                 if (r->out.info) {
23989                         {
23990                                 struct ndr_push *_ndr_info;
23991                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23992                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23993                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23994                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23995                         }
23996                 }
23997                 if (r->out.needed == NULL) {
23998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23999                 }
24000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24001                 if (r->out.server_major_version == NULL) {
24002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24003                 }
24004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24005                 if (r->out.server_minor_version == NULL) {
24006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24007                 }
24008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24010         }
24011         return NDR_ERR_SUCCESS;
24012 }
24013
24014 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24015 {
24016         uint32_t _ptr_architecture;
24017         uint32_t _ptr_buffer;
24018         uint32_t _ptr_info;
24019         TALLOC_CTX *_mem_save_handle_0;
24020         TALLOC_CTX *_mem_save_architecture_0;
24021         TALLOC_CTX *_mem_save_buffer_0;
24022         TALLOC_CTX *_mem_save_info_0;
24023         TALLOC_CTX *_mem_save_needed_0;
24024         TALLOC_CTX *_mem_save_server_major_version_0;
24025         TALLOC_CTX *_mem_save_server_minor_version_0;
24026         if (flags & NDR_IN) {
24027                 ZERO_STRUCT(r->out);
24028
24029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24030                         NDR_PULL_ALLOC(ndr, r->in.handle);
24031                 }
24032                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24033                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24034                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24037                 if (_ptr_architecture) {
24038                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24039                 } else {
24040                         r->in.architecture = NULL;
24041                 }
24042                 if (r->in.architecture) {
24043                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24044                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24047                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24048                                 return 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));
24049                         }
24050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24051                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24053                 }
24054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24056                 if (_ptr_buffer) {
24057                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24058                 } else {
24059                         r->in.buffer = NULL;
24060                 }
24061                 if (r->in.buffer) {
24062                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24063                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24064                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24066                 }
24067                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24070                 NDR_PULL_ALLOC(ndr, r->out.needed);
24071                 ZERO_STRUCTP(r->out.needed);
24072                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24073                 ZERO_STRUCTP(r->out.server_major_version);
24074                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24075                 ZERO_STRUCTP(r->out.server_minor_version);
24076         }
24077         if (flags & NDR_OUT) {
24078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24079                 if (_ptr_info) {
24080                         NDR_PULL_ALLOC(ndr, r->out.info);
24081                 } else {
24082                         r->out.info = NULL;
24083                 }
24084                 if (r->out.info) {
24085                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24086                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24087                         {
24088                                 struct ndr_pull *_ndr_info;
24089                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24090                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24091                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24092                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24093                         }
24094                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24095                 }
24096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24097                         NDR_PULL_ALLOC(ndr, r->out.needed);
24098                 }
24099                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24100                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24101                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24104                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24105                 }
24106                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24111                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24112                 }
24113                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24114                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24117                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24118         }
24119         return NDR_ERR_SUCCESS;
24120 }
24121
24122 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24123 {
24124         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24125         ndr->depth++;
24126         if (flags & NDR_SET_VALUES) {
24127                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24128         }
24129         if (flags & NDR_IN) {
24130                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24131                 ndr->depth++;
24132                 ndr_print_ptr(ndr, "handle", r->in.handle);
24133                 ndr->depth++;
24134                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24135                 ndr->depth--;
24136                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24137                 ndr->depth++;
24138                 if (r->in.architecture) {
24139                         ndr_print_string(ndr, "architecture", r->in.architecture);
24140                 }
24141                 ndr->depth--;
24142                 ndr_print_uint32(ndr, "level", r->in.level);
24143                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24144                 ndr->depth++;
24145                 if (r->in.buffer) {
24146                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24147                 }
24148                 ndr->depth--;
24149                 ndr_print_uint32(ndr, "offered", r->in.offered);
24150                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24151                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24152                 ndr->depth--;
24153         }
24154         if (flags & NDR_OUT) {
24155                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24156                 ndr->depth++;
24157                 ndr_print_ptr(ndr, "info", r->out.info);
24158                 ndr->depth++;
24159                 if (r->out.info) {
24160                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24161                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24162                 }
24163                 ndr->depth--;
24164                 ndr_print_ptr(ndr, "needed", r->out.needed);
24165                 ndr->depth++;
24166                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24167                 ndr->depth--;
24168                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24169                 ndr->depth++;
24170                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24171                 ndr->depth--;
24172                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24173                 ndr->depth++;
24174                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24175                 ndr->depth--;
24176                 ndr_print_WERROR(ndr, "result", r->out.result);
24177                 ndr->depth--;
24178         }
24179         ndr->depth--;
24180 }
24181
24182 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24183 {
24184         if (flags & NDR_IN) {
24185         }
24186         if (flags & NDR_OUT) {
24187                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24188         }
24189         return NDR_ERR_SUCCESS;
24190 }
24191
24192 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24193 {
24194         if (flags & NDR_IN) {
24195         }
24196         if (flags & NDR_OUT) {
24197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24198         }
24199         return NDR_ERR_SUCCESS;
24200 }
24201
24202 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24203 {
24204         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24205         ndr->depth++;
24206         if (flags & NDR_SET_VALUES) {
24207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24208         }
24209         if (flags & NDR_IN) {
24210                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24211                 ndr->depth++;
24212                 ndr->depth--;
24213         }
24214         if (flags & NDR_OUT) {
24215                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24216                 ndr->depth++;
24217                 ndr_print_WERROR(ndr, "result", r->out.result);
24218                 ndr->depth--;
24219         }
24220         ndr->depth--;
24221 }
24222
24223 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24224 {
24225         if (flags & NDR_IN) {
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 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24234 {
24235         if (flags & NDR_IN) {
24236         }
24237         if (flags & NDR_OUT) {
24238                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24239         }
24240         return NDR_ERR_SUCCESS;
24241 }
24242
24243 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24244 {
24245         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24246         ndr->depth++;
24247         if (flags & NDR_SET_VALUES) {
24248                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24249         }
24250         if (flags & NDR_IN) {
24251                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24252                 ndr->depth++;
24253                 ndr->depth--;
24254         }
24255         if (flags & NDR_OUT) {
24256                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24257                 ndr->depth++;
24258                 ndr_print_WERROR(ndr, "result", r->out.result);
24259                 ndr->depth--;
24260         }
24261         ndr->depth--;
24262 }
24263
24264 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24265 {
24266         if (flags & NDR_IN) {
24267                 if (r->in.handle == NULL) {
24268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24269                 }
24270                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24271         }
24272         if (flags & NDR_OUT) {
24273                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24274         }
24275         return NDR_ERR_SUCCESS;
24276 }
24277
24278 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24279 {
24280         TALLOC_CTX *_mem_save_handle_0;
24281         if (flags & NDR_IN) {
24282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24283                         NDR_PULL_ALLOC(ndr, r->in.handle);
24284                 }
24285                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24287                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
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_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24297 {
24298         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
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_FindClosePrinterNotify");
24305                 ndr->depth++;
24306                 ndr_print_ptr(ndr, "handle", r->in.handle);
24307                 ndr->depth++;
24308                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24309                 ndr->depth--;
24310                 ndr->depth--;
24311         }
24312         if (flags & NDR_OUT) {
24313                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24314                 ndr->depth++;
24315                 ndr_print_WERROR(ndr, "result", r->out.result);
24316                 ndr->depth--;
24317         }
24318         ndr->depth--;
24319 }
24320
24321 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24322 {
24323         if (flags & NDR_IN) {
24324         }
24325         if (flags & NDR_OUT) {
24326                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24327         }
24328         return NDR_ERR_SUCCESS;
24329 }
24330
24331 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24332 {
24333         if (flags & NDR_IN) {
24334         }
24335         if (flags & NDR_OUT) {
24336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24337         }
24338         return NDR_ERR_SUCCESS;
24339 }
24340
24341 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24342 {
24343         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24344         ndr->depth++;
24345         if (flags & NDR_SET_VALUES) {
24346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24347         }
24348         if (flags & NDR_IN) {
24349                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24350                 ndr->depth++;
24351                 ndr->depth--;
24352         }
24353         if (flags & NDR_OUT) {
24354                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24355                 ndr->depth++;
24356                 ndr_print_WERROR(ndr, "result", r->out.result);
24357                 ndr->depth--;
24358         }
24359         ndr->depth--;
24360 }
24361
24362 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24363 {
24364         if (flags & NDR_IN) {
24365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24368                 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));
24369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24370                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24373                 if (r->in.buffer) {
24374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24375                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24376                 }
24377         }
24378         if (flags & NDR_OUT) {
24379                 if (r->out.handle == NULL) {
24380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24381                 }
24382                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24383                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24384         }
24385         return NDR_ERR_SUCCESS;
24386 }
24387
24388 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24389 {
24390         uint32_t _ptr_buffer;
24391         TALLOC_CTX *_mem_save_buffer_0;
24392         TALLOC_CTX *_mem_save_handle_0;
24393         if (flags & NDR_IN) {
24394                 ZERO_STRUCT(r->out);
24395
24396                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24397                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24398                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24399                         return 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));
24400                 }
24401                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24402                 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));
24403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24404                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24406                 if (r->in.bufsize > 512) {
24407                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24408                 }
24409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24410                 if (_ptr_buffer) {
24411                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24412                 } else {
24413                         r->in.buffer = NULL;
24414                 }
24415                 if (r->in.buffer) {
24416                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24417                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24418                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24419                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24420                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24422                 }
24423                 NDR_PULL_ALLOC(ndr, r->out.handle);
24424                 ZERO_STRUCTP(r->out.handle);
24425                 if (r->in.buffer) {
24426                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24427                 }
24428         }
24429         if (flags & NDR_OUT) {
24430                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24431                         NDR_PULL_ALLOC(ndr, r->out.handle);
24432                 }
24433                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24434                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24435                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24437                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24438         }
24439         return NDR_ERR_SUCCESS;
24440 }
24441
24442 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24443 {
24444         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24445         ndr->depth++;
24446         if (flags & NDR_SET_VALUES) {
24447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24448         }
24449         if (flags & NDR_IN) {
24450                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24451                 ndr->depth++;
24452                 ndr_print_string(ndr, "server_name", r->in.server_name);
24453                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24454                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24455                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24456                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24457                 ndr->depth++;
24458                 if (r->in.buffer) {
24459                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24460                 }
24461                 ndr->depth--;
24462                 ndr->depth--;
24463         }
24464         if (flags & NDR_OUT) {
24465                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24466                 ndr->depth++;
24467                 ndr_print_ptr(ndr, "handle", r->out.handle);
24468                 ndr->depth++;
24469                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24470                 ndr->depth--;
24471                 ndr_print_WERROR(ndr, "result", r->out.result);
24472                 ndr->depth--;
24473         }
24474         ndr->depth--;
24475 }
24476
24477 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24478 {
24479         if (flags & NDR_IN) {
24480                 if (r->in.handle == NULL) {
24481                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24482                 }
24483                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24484                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24486                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24487                 if (r->in.buffer) {
24488                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24489                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24490                 }
24491         }
24492         if (flags & NDR_OUT) {
24493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24494         }
24495         return NDR_ERR_SUCCESS;
24496 }
24497
24498 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24499 {
24500         uint32_t _ptr_buffer;
24501         TALLOC_CTX *_mem_save_handle_0;
24502         TALLOC_CTX *_mem_save_buffer_0;
24503         if (flags & NDR_IN) {
24504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24505                         NDR_PULL_ALLOC(ndr, r->in.handle);
24506                 }
24507                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24508                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24509                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24511                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24513                 if (r->in.bufsize > 512) {
24514                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24515                 }
24516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24517                 if (_ptr_buffer) {
24518                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24519                 } else {
24520                         r->in.buffer = NULL;
24521                 }
24522                 if (r->in.buffer) {
24523                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24526                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24527                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24529                 }
24530                 if (r->in.buffer) {
24531                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24532                 }
24533         }
24534         if (flags & NDR_OUT) {
24535                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24536         }
24537         return NDR_ERR_SUCCESS;
24538 }
24539
24540 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24541 {
24542         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24543         ndr->depth++;
24544         if (flags & NDR_SET_VALUES) {
24545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24546         }
24547         if (flags & NDR_IN) {
24548                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24549                 ndr->depth++;
24550                 ndr_print_ptr(ndr, "handle", r->in.handle);
24551                 ndr->depth++;
24552                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24553                 ndr->depth--;
24554                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24555                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24556                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24557                 ndr->depth++;
24558                 if (r->in.buffer) {
24559                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24560                 }
24561                 ndr->depth--;
24562                 ndr->depth--;
24563         }
24564         if (flags & NDR_OUT) {
24565                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24566                 ndr->depth++;
24567                 ndr_print_WERROR(ndr, "result", r->out.result);
24568                 ndr->depth--;
24569         }
24570         ndr->depth--;
24571 }
24572
24573 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24574 {
24575         if (flags & NDR_IN) {
24576                 if (r->in.handle == NULL) {
24577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24578                 }
24579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24580         }
24581         if (flags & NDR_OUT) {
24582                 if (r->out.handle == NULL) {
24583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24584                 }
24585                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24586                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24587         }
24588         return NDR_ERR_SUCCESS;
24589 }
24590
24591 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24592 {
24593         TALLOC_CTX *_mem_save_handle_0;
24594         if (flags & NDR_IN) {
24595                 ZERO_STRUCT(r->out);
24596
24597                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24598                         NDR_PULL_ALLOC(ndr, r->in.handle);
24599                 }
24600                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24601                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24602                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24603                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24604                 NDR_PULL_ALLOC(ndr, r->out.handle);
24605                 *r->out.handle = *r->in.handle;
24606         }
24607         if (flags & NDR_OUT) {
24608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24609                         NDR_PULL_ALLOC(ndr, r->out.handle);
24610                 }
24611                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24612                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24615                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24616         }
24617         return NDR_ERR_SUCCESS;
24618 }
24619
24620 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24621 {
24622         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24623         ndr->depth++;
24624         if (flags & NDR_SET_VALUES) {
24625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24626         }
24627         if (flags & NDR_IN) {
24628                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24629                 ndr->depth++;
24630                 ndr_print_ptr(ndr, "handle", r->in.handle);
24631                 ndr->depth++;
24632                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24633                 ndr->depth--;
24634                 ndr->depth--;
24635         }
24636         if (flags & NDR_OUT) {
24637                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24638                 ndr->depth++;
24639                 ndr_print_ptr(ndr, "handle", r->out.handle);
24640                 ndr->depth++;
24641                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24642                 ndr->depth--;
24643                 ndr_print_WERROR(ndr, "result", r->out.result);
24644                 ndr->depth--;
24645         }
24646         ndr->depth--;
24647 }
24648
24649 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24650 {
24651         if (flags & NDR_IN) {
24652         }
24653         if (flags & NDR_OUT) {
24654                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24655         }
24656         return NDR_ERR_SUCCESS;
24657 }
24658
24659 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24660 {
24661         if (flags & NDR_IN) {
24662         }
24663         if (flags & NDR_OUT) {
24664                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24665         }
24666         return NDR_ERR_SUCCESS;
24667 }
24668
24669 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24670 {
24671         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24672         ndr->depth++;
24673         if (flags & NDR_SET_VALUES) {
24674                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24675         }
24676         if (flags & NDR_IN) {
24677                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24678                 ndr->depth++;
24679                 ndr->depth--;
24680         }
24681         if (flags & NDR_OUT) {
24682                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24683                 ndr->depth++;
24684                 ndr_print_WERROR(ndr, "result", r->out.result);
24685                 ndr->depth--;
24686         }
24687         ndr->depth--;
24688 }
24689
24690 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24691 {
24692         if (flags & NDR_IN) {
24693         }
24694         if (flags & NDR_OUT) {
24695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24696         }
24697         return NDR_ERR_SUCCESS;
24698 }
24699
24700 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24701 {
24702         if (flags & NDR_IN) {
24703         }
24704         if (flags & NDR_OUT) {
24705                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24706         }
24707         return NDR_ERR_SUCCESS;
24708 }
24709
24710 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24711 {
24712         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24713         ndr->depth++;
24714         if (flags & NDR_SET_VALUES) {
24715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24716         }
24717         if (flags & NDR_IN) {
24718                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24719                 ndr->depth++;
24720                 ndr->depth--;
24721         }
24722         if (flags & NDR_OUT) {
24723                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24724                 ndr->depth++;
24725                 ndr_print_WERROR(ndr, "result", r->out.result);
24726                 ndr->depth--;
24727         }
24728         ndr->depth--;
24729 }
24730
24731 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24732 {
24733         if (flags & NDR_IN) {
24734         }
24735         if (flags & NDR_OUT) {
24736                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24737         }
24738         return NDR_ERR_SUCCESS;
24739 }
24740
24741 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24742 {
24743         if (flags & NDR_IN) {
24744         }
24745         if (flags & NDR_OUT) {
24746                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24747         }
24748         return NDR_ERR_SUCCESS;
24749 }
24750
24751 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24752 {
24753         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24754         ndr->depth++;
24755         if (flags & NDR_SET_VALUES) {
24756                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24757         }
24758         if (flags & NDR_IN) {
24759                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24760                 ndr->depth++;
24761                 ndr->depth--;
24762         }
24763         if (flags & NDR_OUT) {
24764                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24765                 ndr->depth++;
24766                 ndr_print_WERROR(ndr, "result", r->out.result);
24767                 ndr->depth--;
24768         }
24769         ndr->depth--;
24770 }
24771
24772 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24773 {
24774         if (flags & NDR_IN) {
24775         }
24776         if (flags & NDR_OUT) {
24777                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24778         }
24779         return NDR_ERR_SUCCESS;
24780 }
24781
24782 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24783 {
24784         if (flags & NDR_IN) {
24785         }
24786         if (flags & NDR_OUT) {
24787                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24788         }
24789         return NDR_ERR_SUCCESS;
24790 }
24791
24792 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24793 {
24794         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24795         ndr->depth++;
24796         if (flags & NDR_SET_VALUES) {
24797                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24798         }
24799         if (flags & NDR_IN) {
24800                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24801                 ndr->depth++;
24802                 ndr->depth--;
24803         }
24804         if (flags & NDR_OUT) {
24805                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24806                 ndr->depth++;
24807                 ndr_print_WERROR(ndr, "result", r->out.result);
24808                 ndr->depth--;
24809         }
24810         ndr->depth--;
24811 }
24812
24813 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24814 {
24815         if (flags & NDR_IN) {
24816                 if (r->in.handle == NULL) {
24817                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24818                 }
24819                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24820                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24823                 if (r->in.local_machine) {
24824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24827                         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));
24828                 }
24829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24830                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24831                 if (r->in.notify_options) {
24832                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24833                 }
24834         }
24835         if (flags & NDR_OUT) {
24836                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24837         }
24838         return NDR_ERR_SUCCESS;
24839 }
24840
24841 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24842 {
24843         uint32_t _ptr_local_machine;
24844         uint32_t _ptr_notify_options;
24845         TALLOC_CTX *_mem_save_handle_0;
24846         TALLOC_CTX *_mem_save_local_machine_0;
24847         TALLOC_CTX *_mem_save_notify_options_0;
24848         if (flags & NDR_IN) {
24849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24850                         NDR_PULL_ALLOC(ndr, r->in.handle);
24851                 }
24852                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24853                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24854                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24856                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24858                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24859                 if (_ptr_local_machine) {
24860                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24861                 } else {
24862                         r->in.local_machine = NULL;
24863                 }
24864                 if (r->in.local_machine) {
24865                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24866                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24869                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24870                                 return 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));
24871                         }
24872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24873                         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));
24874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24875                 }
24876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24878                 if (_ptr_notify_options) {
24879                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24880                 } else {
24881                         r->in.notify_options = NULL;
24882                 }
24883                 if (r->in.notify_options) {
24884                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24885                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24886                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24888                 }
24889         }
24890         if (flags & NDR_OUT) {
24891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24892         }
24893         return NDR_ERR_SUCCESS;
24894 }
24895
24896 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24897 {
24898         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24899         ndr->depth++;
24900         if (flags & NDR_SET_VALUES) {
24901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24902         }
24903         if (flags & NDR_IN) {
24904                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24905                 ndr->depth++;
24906                 ndr_print_ptr(ndr, "handle", r->in.handle);
24907                 ndr->depth++;
24908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24909                 ndr->depth--;
24910                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24911                 ndr_print_uint32(ndr, "options", r->in.options);
24912                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24913                 ndr->depth++;
24914                 if (r->in.local_machine) {
24915                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24916                 }
24917                 ndr->depth--;
24918                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24919                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24920                 ndr->depth++;
24921                 if (r->in.notify_options) {
24922                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24923                 }
24924                 ndr->depth--;
24925                 ndr->depth--;
24926         }
24927         if (flags & NDR_OUT) {
24928                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24929                 ndr->depth++;
24930                 ndr_print_WERROR(ndr, "result", r->out.result);
24931                 ndr->depth--;
24932         }
24933         ndr->depth--;
24934 }
24935
24936 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24937 {
24938         if (flags & NDR_IN) {
24939                 if (r->in.handle == NULL) {
24940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24941                 }
24942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24944                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24946                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24947                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24948         }
24949         if (flags & NDR_OUT) {
24950                 if (r->out.reply_result == NULL) {
24951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24952                 }
24953                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24954                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24955         }
24956         return NDR_ERR_SUCCESS;
24957 }
24958
24959 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24960 {
24961         TALLOC_CTX *_mem_save_handle_0;
24962         TALLOC_CTX *_mem_save_reply_result_0;
24963         if (flags & NDR_IN) {
24964                 ZERO_STRUCT(r->out);
24965
24966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24967                         NDR_PULL_ALLOC(ndr, r->in.handle);
24968                 }
24969                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24971                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24973                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24974                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24976                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24977                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24978                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24979                 ZERO_STRUCTP(r->out.reply_result);
24980         }
24981         if (flags & NDR_OUT) {
24982                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24983                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24984                 }
24985                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24986                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24987                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24988                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24989                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24990         }
24991         return NDR_ERR_SUCCESS;
24992 }
24993
24994 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24995 {
24996         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24997         ndr->depth++;
24998         if (flags & NDR_SET_VALUES) {
24999                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25000         }
25001         if (flags & NDR_IN) {
25002                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25003                 ndr->depth++;
25004                 ndr_print_ptr(ndr, "handle", r->in.handle);
25005                 ndr->depth++;
25006                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25007                 ndr->depth--;
25008                 ndr_print_uint32(ndr, "color", r->in.color);
25009                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25010                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25011                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25012                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25013                 ndr->depth--;
25014         }
25015         if (flags & NDR_OUT) {
25016                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25017                 ndr->depth++;
25018                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25019                 ndr->depth++;
25020                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25021                 ndr->depth--;
25022                 ndr_print_WERROR(ndr, "result", r->out.result);
25023                 ndr->depth--;
25024         }
25025         ndr->depth--;
25026 }
25027
25028 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25029 {
25030         if (flags & NDR_IN) {
25031                 if (r->in.handle == NULL) {
25032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25033                 }
25034                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25037                 if (r->in.options) {
25038                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25039                 }
25040         }
25041         if (flags & NDR_OUT) {
25042                 if (r->out.info == NULL) {
25043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25044                 }
25045                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25046                 if (*r->out.info) {
25047                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25048                 }
25049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25050         }
25051         return NDR_ERR_SUCCESS;
25052 }
25053
25054 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25055 {
25056         uint32_t _ptr_options;
25057         uint32_t _ptr_info;
25058         TALLOC_CTX *_mem_save_handle_0;
25059         TALLOC_CTX *_mem_save_options_0;
25060         TALLOC_CTX *_mem_save_info_0;
25061         TALLOC_CTX *_mem_save_info_1;
25062         if (flags & NDR_IN) {
25063                 ZERO_STRUCT(r->out);
25064
25065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25066                         NDR_PULL_ALLOC(ndr, r->in.handle);
25067                 }
25068                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25069                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25070                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25074                 if (_ptr_options) {
25075                         NDR_PULL_ALLOC(ndr, r->in.options);
25076                 } else {
25077                         r->in.options = NULL;
25078                 }
25079                 if (r->in.options) {
25080                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25082                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25084                 }
25085                 NDR_PULL_ALLOC(ndr, r->out.info);
25086                 ZERO_STRUCTP(r->out.info);
25087         }
25088         if (flags & NDR_OUT) {
25089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25090                         NDR_PULL_ALLOC(ndr, r->out.info);
25091                 }
25092                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25093                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25095                 if (_ptr_info) {
25096                         NDR_PULL_ALLOC(ndr, *r->out.info);
25097                 } else {
25098                         *r->out.info = NULL;
25099                 }
25100                 if (*r->out.info) {
25101                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25102                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25103                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25105                 }
25106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25108         }
25109         return NDR_ERR_SUCCESS;
25110 }
25111
25112 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25113 {
25114         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25115         ndr->depth++;
25116         if (flags & NDR_SET_VALUES) {
25117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25118         }
25119         if (flags & NDR_IN) {
25120                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25121                 ndr->depth++;
25122                 ndr_print_ptr(ndr, "handle", r->in.handle);
25123                 ndr->depth++;
25124                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25125                 ndr->depth--;
25126                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25127                 ndr_print_ptr(ndr, "options", r->in.options);
25128                 ndr->depth++;
25129                 if (r->in.options) {
25130                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25131                 }
25132                 ndr->depth--;
25133                 ndr->depth--;
25134         }
25135         if (flags & NDR_OUT) {
25136                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25137                 ndr->depth++;
25138                 ndr_print_ptr(ndr, "info", r->out.info);
25139                 ndr->depth++;
25140                 ndr_print_ptr(ndr, "info", *r->out.info);
25141                 ndr->depth++;
25142                 if (*r->out.info) {
25143                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25144                 }
25145                 ndr->depth--;
25146                 ndr->depth--;
25147                 ndr_print_WERROR(ndr, "result", r->out.result);
25148                 ndr->depth--;
25149         }
25150         ndr->depth--;
25151 }
25152
25153 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25154 {
25155         if (flags & NDR_IN) {
25156         }
25157         if (flags & NDR_OUT) {
25158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25159         }
25160         return NDR_ERR_SUCCESS;
25161 }
25162
25163 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25164 {
25165         if (flags & NDR_IN) {
25166         }
25167         if (flags & NDR_OUT) {
25168                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25169         }
25170         return NDR_ERR_SUCCESS;
25171 }
25172
25173 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25174 {
25175         ndr_print_struct(ndr, name, "spoolss_44");
25176         ndr->depth++;
25177         if (flags & NDR_SET_VALUES) {
25178                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25179         }
25180         if (flags & NDR_IN) {
25181                 ndr_print_struct(ndr, "in", "spoolss_44");
25182                 ndr->depth++;
25183                 ndr->depth--;
25184         }
25185         if (flags & NDR_OUT) {
25186                 ndr_print_struct(ndr, "out", "spoolss_44");
25187                 ndr->depth++;
25188                 ndr_print_WERROR(ndr, "result", r->out.result);
25189                 ndr->depth--;
25190         }
25191         ndr->depth--;
25192 }
25193
25194 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25195 {
25196         if (flags & NDR_IN) {
25197                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25198                 if (r->in.printername) {
25199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25202                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25203                 }
25204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25205                 if (r->in.datatype) {
25206                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25207                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25208                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25209                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25210                 }
25211                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25212                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25214                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25215                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25216         }
25217         if (flags & NDR_OUT) {
25218                 if (r->out.handle == NULL) {
25219                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25220                 }
25221                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25222                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25223         }
25224         return NDR_ERR_SUCCESS;
25225 }
25226
25227 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25228 {
25229         uint32_t _ptr_printername;
25230         uint32_t _ptr_datatype;
25231         TALLOC_CTX *_mem_save_printername_0;
25232         TALLOC_CTX *_mem_save_datatype_0;
25233         TALLOC_CTX *_mem_save_handle_0;
25234         if (flags & NDR_IN) {
25235                 ZERO_STRUCT(r->out);
25236
25237                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25238                 if (_ptr_printername) {
25239                         NDR_PULL_ALLOC(ndr, r->in.printername);
25240                 } else {
25241                         r->in.printername = NULL;
25242                 }
25243                 if (r->in.printername) {
25244                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25245                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25247                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25248                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25249                                 return 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));
25250                         }
25251                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25252                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25254                 }
25255                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25256                 if (_ptr_datatype) {
25257                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25258                 } else {
25259                         r->in.datatype = NULL;
25260                 }
25261                 if (r->in.datatype) {
25262                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25263                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25264                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25265                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25266                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25267                                 return 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));
25268                         }
25269                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25270                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25271                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25272                 }
25273                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25274                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25276                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25277                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25278                 NDR_PULL_ALLOC(ndr, r->out.handle);
25279                 ZERO_STRUCTP(r->out.handle);
25280         }
25281         if (flags & NDR_OUT) {
25282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25283                         NDR_PULL_ALLOC(ndr, r->out.handle);
25284                 }
25285                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25286                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25287                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25289                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25290         }
25291         return NDR_ERR_SUCCESS;
25292 }
25293
25294 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25295 {
25296         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25297         ndr->depth++;
25298         if (flags & NDR_SET_VALUES) {
25299                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25300         }
25301         if (flags & NDR_IN) {
25302                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25303                 ndr->depth++;
25304                 ndr_print_ptr(ndr, "printername", r->in.printername);
25305                 ndr->depth++;
25306                 if (r->in.printername) {
25307                         ndr_print_string(ndr, "printername", r->in.printername);
25308                 }
25309                 ndr->depth--;
25310                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25311                 ndr->depth++;
25312                 if (r->in.datatype) {
25313                         ndr_print_string(ndr, "datatype", r->in.datatype);
25314                 }
25315                 ndr->depth--;
25316                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25317                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25318                 ndr_print_uint32(ndr, "level", r->in.level);
25319                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25320                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25321                 ndr->depth--;
25322         }
25323         if (flags & NDR_OUT) {
25324                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25325                 ndr->depth++;
25326                 ndr_print_ptr(ndr, "handle", r->out.handle);
25327                 ndr->depth++;
25328                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25329                 ndr->depth--;
25330                 ndr_print_WERROR(ndr, "result", r->out.result);
25331                 ndr->depth--;
25332         }
25333         ndr->depth--;
25334 }
25335
25336 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25337 {
25338         if (flags & NDR_IN) {
25339                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25340                 if (r->in.server) {
25341                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25342                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25343                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25344                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25345                 }
25346                 if (r->in.info_ctr == NULL) {
25347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25348                 }
25349                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25350                 if (r->in.devmode_ctr == NULL) {
25351                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25352                 }
25353                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25354                 if (r->in.secdesc_ctr == NULL) {
25355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25356                 }
25357                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25358                 if (r->in.userlevel_ctr == NULL) {
25359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25360                 }
25361                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25362         }
25363         if (flags & NDR_OUT) {
25364                 if (r->out.handle == NULL) {
25365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25366                 }
25367                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25369         }
25370         return NDR_ERR_SUCCESS;
25371 }
25372
25373 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25374 {
25375         uint32_t _ptr_server;
25376         TALLOC_CTX *_mem_save_server_0;
25377         TALLOC_CTX *_mem_save_info_ctr_0;
25378         TALLOC_CTX *_mem_save_devmode_ctr_0;
25379         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25380         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25381         TALLOC_CTX *_mem_save_handle_0;
25382         if (flags & NDR_IN) {
25383                 ZERO_STRUCT(r->out);
25384
25385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25386                 if (_ptr_server) {
25387                         NDR_PULL_ALLOC(ndr, r->in.server);
25388                 } else {
25389                         r->in.server = NULL;
25390                 }
25391                 if (r->in.server) {
25392                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25393                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25395                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25396                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25397                                 return 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));
25398                         }
25399                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25400                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25401                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25402                 }
25403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25404                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25405                 }
25406                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25407                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25408                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25410                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25411                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25412                 }
25413                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25414                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25415                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25416                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25418                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25419                 }
25420                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25422                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25425                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25426                 }
25427                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25428                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25429                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25431                 NDR_PULL_ALLOC(ndr, r->out.handle);
25432                 ZERO_STRUCTP(r->out.handle);
25433         }
25434         if (flags & NDR_OUT) {
25435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25436                         NDR_PULL_ALLOC(ndr, r->out.handle);
25437                 }
25438                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25440                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25442                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25443         }
25444         return NDR_ERR_SUCCESS;
25445 }
25446
25447 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25448 {
25449         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25450         ndr->depth++;
25451         if (flags & NDR_SET_VALUES) {
25452                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25453         }
25454         if (flags & NDR_IN) {
25455                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25456                 ndr->depth++;
25457                 ndr_print_ptr(ndr, "server", r->in.server);
25458                 ndr->depth++;
25459                 if (r->in.server) {
25460                         ndr_print_string(ndr, "server", r->in.server);
25461                 }
25462                 ndr->depth--;
25463                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25464                 ndr->depth++;
25465                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25466                 ndr->depth--;
25467                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25468                 ndr->depth++;
25469                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25470                 ndr->depth--;
25471                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25472                 ndr->depth++;
25473                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25474                 ndr->depth--;
25475                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25476                 ndr->depth++;
25477                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25478                 ndr->depth--;
25479                 ndr->depth--;
25480         }
25481         if (flags & NDR_OUT) {
25482                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25483                 ndr->depth++;
25484                 ndr_print_ptr(ndr, "handle", r->out.handle);
25485                 ndr->depth++;
25486                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25487                 ndr->depth--;
25488                 ndr_print_WERROR(ndr, "result", r->out.result);
25489                 ndr->depth--;
25490         }
25491         ndr->depth--;
25492 }
25493
25494 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25495 {
25496         if (flags & NDR_IN) {
25497         }
25498         if (flags & NDR_OUT) {
25499                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25500         }
25501         return NDR_ERR_SUCCESS;
25502 }
25503
25504 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25505 {
25506         if (flags & NDR_IN) {
25507         }
25508         if (flags & NDR_OUT) {
25509                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25510         }
25511         return NDR_ERR_SUCCESS;
25512 }
25513
25514 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25515 {
25516         ndr_print_struct(ndr, name, "spoolss_47");
25517         ndr->depth++;
25518         if (flags & NDR_SET_VALUES) {
25519                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25520         }
25521         if (flags & NDR_IN) {
25522                 ndr_print_struct(ndr, "in", "spoolss_47");
25523                 ndr->depth++;
25524                 ndr->depth--;
25525         }
25526         if (flags & NDR_OUT) {
25527                 ndr_print_struct(ndr, "out", "spoolss_47");
25528                 ndr->depth++;
25529                 ndr_print_WERROR(ndr, "result", r->out.result);
25530                 ndr->depth--;
25531         }
25532         ndr->depth--;
25533 }
25534
25535 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25536 {
25537         if (flags & NDR_IN) {
25538                 if (r->in.handle == NULL) {
25539                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25540                 }
25541                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25545         }
25546         if (flags & NDR_OUT) {
25547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25548                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25549                 if (r->out.value_needed == NULL) {
25550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25551                 }
25552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25553                 if (r->out.printerdata_type == NULL) {
25554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25555                 }
25556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25557                 if (r->out.buffer == NULL) {
25558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25559                 }
25560                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25561                 if (r->out.data_needed == NULL) {
25562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25563                 }
25564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25566         }
25567         return NDR_ERR_SUCCESS;
25568 }
25569
25570 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25571 {
25572         TALLOC_CTX *_mem_save_handle_0;
25573         TALLOC_CTX *_mem_save_value_needed_0;
25574         TALLOC_CTX *_mem_save_printerdata_type_0;
25575         TALLOC_CTX *_mem_save_buffer_0;
25576         TALLOC_CTX *_mem_save_data_needed_0;
25577         if (flags & NDR_IN) {
25578                 ZERO_STRUCT(r->out);
25579
25580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25581                         NDR_PULL_ALLOC(ndr, r->in.handle);
25582                 }
25583                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25585                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25590                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25591                 ZERO_STRUCTP(r->out.value_needed);
25592                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25593                 ZERO_STRUCTP(r->out.printerdata_type);
25594                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25595                 ZERO_STRUCTP(r->out.buffer);
25596                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25597                 ZERO_STRUCTP(r->out.data_needed);
25598         }
25599         if (flags & NDR_OUT) {
25600                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25601                 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));
25602                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25603                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25604                 }
25605                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25606                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25609                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25610                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25611                 }
25612                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25613                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25617                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25618                 }
25619                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25621                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25624                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25625                 }
25626                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25627                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25631                 if (r->out.value_name) {
25632                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25633                 }
25634         }
25635         return NDR_ERR_SUCCESS;
25636 }
25637
25638 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25639 {
25640         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25641         ndr->depth++;
25642         if (flags & NDR_SET_VALUES) {
25643                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25644         }
25645         if (flags & NDR_IN) {
25646                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25647                 ndr->depth++;
25648                 ndr_print_ptr(ndr, "handle", r->in.handle);
25649                 ndr->depth++;
25650                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25651                 ndr->depth--;
25652                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25653                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25654                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25655                 ndr->depth--;
25656         }
25657         if (flags & NDR_OUT) {
25658                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25659                 ndr->depth++;
25660                 ndr_print_string(ndr, "value_name", r->out.value_name);
25661                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25662                 ndr->depth++;
25663                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25664                 ndr->depth--;
25665                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25666                 ndr->depth++;
25667                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25668                 ndr->depth--;
25669                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25670                 ndr->depth++;
25671                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25672                 ndr->depth--;
25673                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25674                 ndr->depth++;
25675                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25676                 ndr->depth--;
25677                 ndr_print_WERROR(ndr, "result", r->out.result);
25678                 ndr->depth--;
25679         }
25680         ndr->depth--;
25681 }
25682
25683 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25684 {
25685         if (flags & NDR_IN) {
25686                 if (r->in.handle == NULL) {
25687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25688                 }
25689                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25693                 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));
25694         }
25695         if (flags & NDR_OUT) {
25696                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25697         }
25698         return NDR_ERR_SUCCESS;
25699 }
25700
25701 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25702 {
25703         TALLOC_CTX *_mem_save_handle_0;
25704         if (flags & NDR_IN) {
25705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25706                         NDR_PULL_ALLOC(ndr, r->in.handle);
25707                 }
25708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25712                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25713                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25714                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25715                         return 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));
25716                 }
25717                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25718                 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));
25719         }
25720         if (flags & NDR_OUT) {
25721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25722         }
25723         return NDR_ERR_SUCCESS;
25724 }
25725
25726 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25727 {
25728         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25729         ndr->depth++;
25730         if (flags & NDR_SET_VALUES) {
25731                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25732         }
25733         if (flags & NDR_IN) {
25734                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25735                 ndr->depth++;
25736                 ndr_print_ptr(ndr, "handle", r->in.handle);
25737                 ndr->depth++;
25738                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25739                 ndr->depth--;
25740                 ndr_print_string(ndr, "value_name", r->in.value_name);
25741                 ndr->depth--;
25742         }
25743         if (flags & NDR_OUT) {
25744                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25745                 ndr->depth++;
25746                 ndr_print_WERROR(ndr, "result", r->out.result);
25747                 ndr->depth--;
25748         }
25749         ndr->depth--;
25750 }
25751
25752 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25753 {
25754         if (flags & NDR_IN) {
25755         }
25756         if (flags & NDR_OUT) {
25757                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25758         }
25759         return NDR_ERR_SUCCESS;
25760 }
25761
25762 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25763 {
25764         if (flags & NDR_IN) {
25765         }
25766         if (flags & NDR_OUT) {
25767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25768         }
25769         return NDR_ERR_SUCCESS;
25770 }
25771
25772 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25773 {
25774         ndr_print_struct(ndr, name, "spoolss_4a");
25775         ndr->depth++;
25776         if (flags & NDR_SET_VALUES) {
25777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25778         }
25779         if (flags & NDR_IN) {
25780                 ndr_print_struct(ndr, "in", "spoolss_4a");
25781                 ndr->depth++;
25782                 ndr->depth--;
25783         }
25784         if (flags & NDR_OUT) {
25785                 ndr_print_struct(ndr, "out", "spoolss_4a");
25786                 ndr->depth++;
25787                 ndr_print_WERROR(ndr, "result", r->out.result);
25788                 ndr->depth--;
25789         }
25790         ndr->depth--;
25791 }
25792
25793 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25794 {
25795         if (flags & NDR_IN) {
25796         }
25797         if (flags & NDR_OUT) {
25798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25799         }
25800         return NDR_ERR_SUCCESS;
25801 }
25802
25803 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25804 {
25805         if (flags & NDR_IN) {
25806         }
25807         if (flags & NDR_OUT) {
25808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25809         }
25810         return NDR_ERR_SUCCESS;
25811 }
25812
25813 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25814 {
25815         ndr_print_struct(ndr, name, "spoolss_4b");
25816         ndr->depth++;
25817         if (flags & NDR_SET_VALUES) {
25818                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25819         }
25820         if (flags & NDR_IN) {
25821                 ndr_print_struct(ndr, "in", "spoolss_4b");
25822                 ndr->depth++;
25823                 ndr->depth--;
25824         }
25825         if (flags & NDR_OUT) {
25826                 ndr_print_struct(ndr, "out", "spoolss_4b");
25827                 ndr->depth++;
25828                 ndr_print_WERROR(ndr, "result", r->out.result);
25829                 ndr->depth--;
25830         }
25831         ndr->depth--;
25832 }
25833
25834 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25835 {
25836         if (flags & NDR_IN) {
25837         }
25838         if (flags & NDR_OUT) {
25839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25840         }
25841         return NDR_ERR_SUCCESS;
25842 }
25843
25844 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25845 {
25846         if (flags & NDR_IN) {
25847         }
25848         if (flags & NDR_OUT) {
25849                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25850         }
25851         return NDR_ERR_SUCCESS;
25852 }
25853
25854 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25855 {
25856         ndr_print_struct(ndr, name, "spoolss_4c");
25857         ndr->depth++;
25858         if (flags & NDR_SET_VALUES) {
25859                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25860         }
25861         if (flags & NDR_IN) {
25862                 ndr_print_struct(ndr, "in", "spoolss_4c");
25863                 ndr->depth++;
25864                 ndr->depth--;
25865         }
25866         if (flags & NDR_OUT) {
25867                 ndr_print_struct(ndr, "out", "spoolss_4c");
25868                 ndr->depth++;
25869                 ndr_print_WERROR(ndr, "result", r->out.result);
25870                 ndr->depth--;
25871         }
25872         ndr->depth--;
25873 }
25874
25875 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25876 {
25877         if (flags & NDR_IN) {
25878                 if (r->in.handle == NULL) {
25879                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25880                 }
25881                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25885                 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));
25886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25889                 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));
25890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25891                 if (r->in.buffer == NULL) {
25892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25893                 }
25894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25895                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25897         }
25898         if (flags & NDR_OUT) {
25899                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25900         }
25901         return NDR_ERR_SUCCESS;
25902 }
25903
25904 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25905 {
25906         TALLOC_CTX *_mem_save_handle_0;
25907         if (flags & NDR_IN) {
25908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25909                         NDR_PULL_ALLOC(ndr, r->in.handle);
25910                 }
25911                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25912                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25913                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25915                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25916                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25917                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25918                         return 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));
25919                 }
25920                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25921                 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));
25922                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25923                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25924                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25925                         return 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));
25926                 }
25927                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25928                 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));
25929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25930                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25932                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25933                 }
25934                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25936                 if (r->in.buffer) {
25937                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25938                 }
25939         }
25940         if (flags & NDR_OUT) {
25941                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25942         }
25943         return NDR_ERR_SUCCESS;
25944 }
25945
25946 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25947 {
25948         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25949         ndr->depth++;
25950         if (flags & NDR_SET_VALUES) {
25951                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25952         }
25953         if (flags & NDR_IN) {
25954                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25955                 ndr->depth++;
25956                 ndr_print_ptr(ndr, "handle", r->in.handle);
25957                 ndr->depth++;
25958                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25959                 ndr->depth--;
25960                 ndr_print_string(ndr, "key_name", r->in.key_name);
25961                 ndr_print_string(ndr, "value_name", r->in.value_name);
25962                 ndr_print_uint32(ndr, "type", r->in.type);
25963                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25964                 ndr->depth++;
25965                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25966                 ndr->depth--;
25967                 ndr_print_uint32(ndr, "offered", r->in.offered);
25968                 ndr->depth--;
25969         }
25970         if (flags & NDR_OUT) {
25971                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25972                 ndr->depth++;
25973                 ndr_print_WERROR(ndr, "result", r->out.result);
25974                 ndr->depth--;
25975         }
25976         ndr->depth--;
25977 }
25978
25979 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25980 {
25981         if (flags & NDR_IN) {
25982                 if (r->in.handle == NULL) {
25983                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25984                 }
25985                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25989                 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));
25990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25993                 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));
25994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25995         }
25996         if (flags & NDR_OUT) {
25997                 if (r->out.type == NULL) {
25998                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25999                 }
26000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
26001                 if (r->out.buffer == NULL) {
26002                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26003                 }
26004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26005                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26006                 if (r->out.needed == NULL) {
26007                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26008                 }
26009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26010                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26011         }
26012         return NDR_ERR_SUCCESS;
26013 }
26014
26015 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26016 {
26017         TALLOC_CTX *_mem_save_handle_0;
26018         TALLOC_CTX *_mem_save_type_0;
26019         TALLOC_CTX *_mem_save_needed_0;
26020         if (flags & NDR_IN) {
26021                 ZERO_STRUCT(r->out);
26022
26023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26024                         NDR_PULL_ALLOC(ndr, r->in.handle);
26025                 }
26026                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26027                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26028                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26030                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26031                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26032                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26033                         return 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));
26034                 }
26035                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26036                 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));
26037                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26038                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26039                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26040                         return 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));
26041                 }
26042                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26043                 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));
26044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26045                 NDR_PULL_ALLOC(ndr, r->out.type);
26046                 ZERO_STRUCTP(r->out.type);
26047                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26048                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26049                 NDR_PULL_ALLOC(ndr, r->out.needed);
26050                 ZERO_STRUCTP(r->out.needed);
26051         }
26052         if (flags & NDR_OUT) {
26053                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26054                         NDR_PULL_ALLOC(ndr, r->out.type);
26055                 }
26056                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26057                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
26059                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26060                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26061                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26062                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26063                 }
26064                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26066                         NDR_PULL_ALLOC(ndr, r->out.needed);
26067                 }
26068                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26069                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26073                 if (r->out.buffer) {
26074                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26075                 }
26076         }
26077         return NDR_ERR_SUCCESS;
26078 }
26079
26080 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26081 {
26082         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26083         ndr->depth++;
26084         if (flags & NDR_SET_VALUES) {
26085                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26086         }
26087         if (flags & NDR_IN) {
26088                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26089                 ndr->depth++;
26090                 ndr_print_ptr(ndr, "handle", r->in.handle);
26091                 ndr->depth++;
26092                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26093                 ndr->depth--;
26094                 ndr_print_string(ndr, "key_name", r->in.key_name);
26095                 ndr_print_string(ndr, "value_name", r->in.value_name);
26096                 ndr_print_uint32(ndr, "offered", r->in.offered);
26097                 ndr->depth--;
26098         }
26099         if (flags & NDR_OUT) {
26100                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26101                 ndr->depth++;
26102                 ndr_print_ptr(ndr, "type", r->out.type);
26103                 ndr->depth++;
26104                 ndr_print_uint32(ndr, "type", *r->out.type);
26105                 ndr->depth--;
26106                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26107                 ndr->depth++;
26108                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26109                 ndr->depth--;
26110                 ndr_print_ptr(ndr, "needed", r->out.needed);
26111                 ndr->depth++;
26112                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26113                 ndr->depth--;
26114                 ndr_print_WERROR(ndr, "result", r->out.result);
26115                 ndr->depth--;
26116         }
26117         ndr->depth--;
26118 }
26119
26120 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26121 {
26122         if (flags & NDR_IN) {
26123                 if (r->in.handle == NULL) {
26124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26125                 }
26126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26130                 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));
26131                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26132         }
26133         if (flags & NDR_OUT) {
26134                 if (r->out.buffer == NULL) {
26135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26136                 }
26137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26138                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26139                 if (r->out.needed == NULL) {
26140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26141                 }
26142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26143                 if (r->out.count == NULL) {
26144                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26145                 }
26146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26147                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26148         }
26149         return NDR_ERR_SUCCESS;
26150 }
26151
26152 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26153 {
26154         TALLOC_CTX *_mem_save_handle_0;
26155         TALLOC_CTX *_mem_save_needed_0;
26156         TALLOC_CTX *_mem_save_count_0;
26157         if (flags & NDR_IN) {
26158                 ZERO_STRUCT(r->out);
26159
26160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26161                         NDR_PULL_ALLOC(ndr, r->in.handle);
26162                 }
26163                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26167                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26168                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26169                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26170                         return 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));
26171                 }
26172                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26173                 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));
26174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26175                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26176                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26177                 NDR_PULL_ALLOC(ndr, r->out.needed);
26178                 ZERO_STRUCTP(r->out.needed);
26179                 NDR_PULL_ALLOC(ndr, r->out.count);
26180                 ZERO_STRUCTP(r->out.count);
26181         }
26182         if (flags & NDR_OUT) {
26183                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26185                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26186                 }
26187                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26189                         NDR_PULL_ALLOC(ndr, r->out.needed);
26190                 }
26191                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26192                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26195                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26196                         NDR_PULL_ALLOC(ndr, r->out.count);
26197                 }
26198                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26199                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26201                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26202                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26203                 if (r->out.buffer) {
26204                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26205                 }
26206         }
26207         return NDR_ERR_SUCCESS;
26208 }
26209
26210 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26211 {
26212         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26213         ndr->depth++;
26214         if (flags & NDR_SET_VALUES) {
26215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26216         }
26217         if (flags & NDR_IN) {
26218                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26219                 ndr->depth++;
26220                 ndr_print_ptr(ndr, "handle", r->in.handle);
26221                 ndr->depth++;
26222                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26223                 ndr->depth--;
26224                 ndr_print_string(ndr, "key_name", r->in.key_name);
26225                 ndr_print_uint32(ndr, "offered", r->in.offered);
26226                 ndr->depth--;
26227         }
26228         if (flags & NDR_OUT) {
26229                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26230                 ndr->depth++;
26231                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26232                 ndr->depth++;
26233                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26234                 ndr->depth--;
26235                 ndr_print_ptr(ndr, "needed", r->out.needed);
26236                 ndr->depth++;
26237                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26238                 ndr->depth--;
26239                 ndr_print_ptr(ndr, "count", r->out.count);
26240                 ndr->depth++;
26241                 ndr_print_uint32(ndr, "count", *r->out.count);
26242                 ndr->depth--;
26243                 ndr_print_WERROR(ndr, "result", r->out.result);
26244                 ndr->depth--;
26245         }
26246         ndr->depth--;
26247 }
26248
26249 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26250 {
26251         uint32_t cntr_key_buffer_1;
26252         if (flags & NDR_IN) {
26253                 if (r->in.handle == NULL) {
26254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26255                 }
26256                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26260                 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));
26261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
26262         }
26263         if (flags & NDR_OUT) {
26264                 if (r->out.key_buffer == NULL) {
26265                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26266                 }
26267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
26268                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26269                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26270                 }
26271                 if (r->out.needed == NULL) {
26272                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26273                 }
26274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26275                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26276         }
26277         return NDR_ERR_SUCCESS;
26278 }
26279
26280 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26281 {
26282         uint32_t cntr_key_buffer_1;
26283         TALLOC_CTX *_mem_save_handle_0;
26284         TALLOC_CTX *_mem_save_key_buffer_1;
26285         TALLOC_CTX *_mem_save_needed_0;
26286         if (flags & NDR_IN) {
26287                 ZERO_STRUCT(r->out);
26288
26289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26290                         NDR_PULL_ALLOC(ndr, r->in.handle);
26291                 }
26292                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26294                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26296                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26297                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26298                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26299                         return 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));
26300                 }
26301                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26302                 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));
26303                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
26304                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
26305                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
26306                 NDR_PULL_ALLOC(ndr, r->out.needed);
26307                 ZERO_STRUCTP(r->out.needed);
26308         }
26309         if (flags & NDR_OUT) {
26310                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26312                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26313                 }
26314                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26316                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26317                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26318                 }
26319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26321                         NDR_PULL_ALLOC(ndr, r->out.needed);
26322                 }
26323                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26328                 if (r->out.key_buffer) {
26329                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
26330                 }
26331         }
26332         return NDR_ERR_SUCCESS;
26333 }
26334
26335 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26336 {
26337         uint32_t cntr_key_buffer_1;
26338         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26339         ndr->depth++;
26340         if (flags & NDR_SET_VALUES) {
26341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26342         }
26343         if (flags & NDR_IN) {
26344                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26345                 ndr->depth++;
26346                 ndr_print_ptr(ndr, "handle", r->in.handle);
26347                 ndr->depth++;
26348                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26349                 ndr->depth--;
26350                 ndr_print_string(ndr, "key_name", r->in.key_name);
26351                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
26352                 ndr->depth--;
26353         }
26354         if (flags & NDR_OUT) {
26355                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26356                 ndr->depth++;
26357                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26358                 ndr->depth++;
26359                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
26360                 ndr->depth++;
26361                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
26362                         char *idx_1=NULL;
26363                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26364                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26365                                 free(idx_1);
26366                         }
26367                 }
26368                 ndr->depth--;
26369                 ndr->depth--;
26370                 ndr_print_ptr(ndr, "needed", r->out.needed);
26371                 ndr->depth++;
26372                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26373                 ndr->depth--;
26374                 ndr_print_WERROR(ndr, "result", r->out.result);
26375                 ndr->depth--;
26376         }
26377         ndr->depth--;
26378 }
26379
26380 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26381 {
26382         if (flags & NDR_IN) {
26383                 if (r->in.handle == NULL) {
26384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26385                 }
26386                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26390                 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));
26391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26394                 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));
26395         }
26396         if (flags & NDR_OUT) {
26397                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26398         }
26399         return NDR_ERR_SUCCESS;
26400 }
26401
26402 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26403 {
26404         TALLOC_CTX *_mem_save_handle_0;
26405         if (flags & NDR_IN) {
26406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26407                         NDR_PULL_ALLOC(ndr, r->in.handle);
26408                 }
26409                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26411                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26413                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26414                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26415                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26416                         return 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));
26417                 }
26418                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26419                 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));
26420                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26421                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26422                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26423                         return 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));
26424                 }
26425                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26426                 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));
26427         }
26428         if (flags & NDR_OUT) {
26429                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26430         }
26431         return NDR_ERR_SUCCESS;
26432 }
26433
26434 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26435 {
26436         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26437         ndr->depth++;
26438         if (flags & NDR_SET_VALUES) {
26439                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26440         }
26441         if (flags & NDR_IN) {
26442                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26443                 ndr->depth++;
26444                 ndr_print_ptr(ndr, "handle", r->in.handle);
26445                 ndr->depth++;
26446                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26447                 ndr->depth--;
26448                 ndr_print_string(ndr, "key_name", r->in.key_name);
26449                 ndr_print_string(ndr, "value_name", r->in.value_name);
26450                 ndr->depth--;
26451         }
26452         if (flags & NDR_OUT) {
26453                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26454                 ndr->depth++;
26455                 ndr_print_WERROR(ndr, "result", r->out.result);
26456                 ndr->depth--;
26457         }
26458         ndr->depth--;
26459 }
26460
26461 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26462 {
26463         if (flags & NDR_IN) {
26464                 if (r->in.handle == NULL) {
26465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26466                 }
26467                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26471                 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));
26472         }
26473         if (flags & NDR_OUT) {
26474                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26475         }
26476         return NDR_ERR_SUCCESS;
26477 }
26478
26479 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26480 {
26481         TALLOC_CTX *_mem_save_handle_0;
26482         if (flags & NDR_IN) {
26483                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26484                         NDR_PULL_ALLOC(ndr, r->in.handle);
26485                 }
26486                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26487                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26488                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26489                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26490                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26491                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26492                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26493                         return 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));
26494                 }
26495                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26496                 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));
26497         }
26498         if (flags & NDR_OUT) {
26499                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26500         }
26501         return NDR_ERR_SUCCESS;
26502 }
26503
26504 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26505 {
26506         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26507         ndr->depth++;
26508         if (flags & NDR_SET_VALUES) {
26509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26510         }
26511         if (flags & NDR_IN) {
26512                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26513                 ndr->depth++;
26514                 ndr_print_ptr(ndr, "handle", r->in.handle);
26515                 ndr->depth++;
26516                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26517                 ndr->depth--;
26518                 ndr_print_string(ndr, "key_name", r->in.key_name);
26519                 ndr->depth--;
26520         }
26521         if (flags & NDR_OUT) {
26522                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26523                 ndr->depth++;
26524                 ndr_print_WERROR(ndr, "result", r->out.result);
26525                 ndr->depth--;
26526         }
26527         ndr->depth--;
26528 }
26529
26530 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26531 {
26532         if (flags & NDR_IN) {
26533         }
26534         if (flags & NDR_OUT) {
26535                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26536         }
26537         return NDR_ERR_SUCCESS;
26538 }
26539
26540 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26541 {
26542         if (flags & NDR_IN) {
26543         }
26544         if (flags & NDR_OUT) {
26545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26546         }
26547         return NDR_ERR_SUCCESS;
26548 }
26549
26550 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26551 {
26552         ndr_print_struct(ndr, name, "spoolss_53");
26553         ndr->depth++;
26554         if (flags & NDR_SET_VALUES) {
26555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26556         }
26557         if (flags & NDR_IN) {
26558                 ndr_print_struct(ndr, "in", "spoolss_53");
26559                 ndr->depth++;
26560                 ndr->depth--;
26561         }
26562         if (flags & NDR_OUT) {
26563                 ndr_print_struct(ndr, "out", "spoolss_53");
26564                 ndr->depth++;
26565                 ndr_print_WERROR(ndr, "result", r->out.result);
26566                 ndr->depth--;
26567         }
26568         ndr->depth--;
26569 }
26570
26571 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26572 {
26573         if (flags & NDR_IN) {
26574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26575                 if (r->in.server) {
26576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26577                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26579                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26580                 }
26581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26583                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26584                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26588                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26589                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26591         }
26592         if (flags & NDR_OUT) {
26593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26594         }
26595         return NDR_ERR_SUCCESS;
26596 }
26597
26598 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26599 {
26600         uint32_t _ptr_server;
26601         TALLOC_CTX *_mem_save_server_0;
26602         if (flags & NDR_IN) {
26603                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26604                 if (_ptr_server) {
26605                         NDR_PULL_ALLOC(ndr, r->in.server);
26606                 } else {
26607                         r->in.server = NULL;
26608                 }
26609                 if (r->in.server) {
26610                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26611                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26612                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26613                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26614                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26615                                 return 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));
26616                         }
26617                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26618                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26620                 }
26621                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26622                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26623                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26624                         return 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));
26625                 }
26626                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26627                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26628                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26629                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26630                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26631                         return 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));
26632                 }
26633                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26634                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26635                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26637         }
26638         if (flags & NDR_OUT) {
26639                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26640         }
26641         return NDR_ERR_SUCCESS;
26642 }
26643
26644 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26645 {
26646         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26647         ndr->depth++;
26648         if (flags & NDR_SET_VALUES) {
26649                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26650         }
26651         if (flags & NDR_IN) {
26652                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26653                 ndr->depth++;
26654                 ndr_print_ptr(ndr, "server", r->in.server);
26655                 ndr->depth++;
26656                 if (r->in.server) {
26657                         ndr_print_string(ndr, "server", r->in.server);
26658                 }
26659                 ndr->depth--;
26660                 ndr_print_string(ndr, "architecture", r->in.architecture);
26661                 ndr_print_string(ndr, "driver", r->in.driver);
26662                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26663                 ndr_print_uint32(ndr, "version", r->in.version);
26664                 ndr->depth--;
26665         }
26666         if (flags & NDR_OUT) {
26667                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26668                 ndr->depth++;
26669                 ndr_print_WERROR(ndr, "result", r->out.result);
26670                 ndr->depth--;
26671         }
26672         ndr->depth--;
26673 }
26674
26675 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26676 {
26677         if (flags & NDR_IN) {
26678         }
26679         if (flags & NDR_OUT) {
26680                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26681         }
26682         return NDR_ERR_SUCCESS;
26683 }
26684
26685 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26686 {
26687         if (flags & NDR_IN) {
26688         }
26689         if (flags & NDR_OUT) {
26690                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26691         }
26692         return NDR_ERR_SUCCESS;
26693 }
26694
26695 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26696 {
26697         ndr_print_struct(ndr, name, "spoolss_55");
26698         ndr->depth++;
26699         if (flags & NDR_SET_VALUES) {
26700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26701         }
26702         if (flags & NDR_IN) {
26703                 ndr_print_struct(ndr, "in", "spoolss_55");
26704                 ndr->depth++;
26705                 ndr->depth--;
26706         }
26707         if (flags & NDR_OUT) {
26708                 ndr_print_struct(ndr, "out", "spoolss_55");
26709                 ndr->depth++;
26710                 ndr_print_WERROR(ndr, "result", r->out.result);
26711                 ndr->depth--;
26712         }
26713         ndr->depth--;
26714 }
26715
26716 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26717 {
26718         if (flags & NDR_IN) {
26719         }
26720         if (flags & NDR_OUT) {
26721                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26722         }
26723         return NDR_ERR_SUCCESS;
26724 }
26725
26726 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26727 {
26728         if (flags & NDR_IN) {
26729         }
26730         if (flags & NDR_OUT) {
26731                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26732         }
26733         return NDR_ERR_SUCCESS;
26734 }
26735
26736 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26737 {
26738         ndr_print_struct(ndr, name, "spoolss_56");
26739         ndr->depth++;
26740         if (flags & NDR_SET_VALUES) {
26741                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26742         }
26743         if (flags & NDR_IN) {
26744                 ndr_print_struct(ndr, "in", "spoolss_56");
26745                 ndr->depth++;
26746                 ndr->depth--;
26747         }
26748         if (flags & NDR_OUT) {
26749                 ndr_print_struct(ndr, "out", "spoolss_56");
26750                 ndr->depth++;
26751                 ndr_print_WERROR(ndr, "result", r->out.result);
26752                 ndr->depth--;
26753         }
26754         ndr->depth--;
26755 }
26756
26757 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26758 {
26759         if (flags & NDR_IN) {
26760         }
26761         if (flags & NDR_OUT) {
26762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26763         }
26764         return NDR_ERR_SUCCESS;
26765 }
26766
26767 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26768 {
26769         if (flags & NDR_IN) {
26770         }
26771         if (flags & NDR_OUT) {
26772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26773         }
26774         return NDR_ERR_SUCCESS;
26775 }
26776
26777 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26778 {
26779         ndr_print_struct(ndr, name, "spoolss_57");
26780         ndr->depth++;
26781         if (flags & NDR_SET_VALUES) {
26782                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26783         }
26784         if (flags & NDR_IN) {
26785                 ndr_print_struct(ndr, "in", "spoolss_57");
26786                 ndr->depth++;
26787                 ndr->depth--;
26788         }
26789         if (flags & NDR_OUT) {
26790                 ndr_print_struct(ndr, "out", "spoolss_57");
26791                 ndr->depth++;
26792                 ndr_print_WERROR(ndr, "result", r->out.result);
26793                 ndr->depth--;
26794         }
26795         ndr->depth--;
26796 }
26797
26798 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26799 {
26800         if (flags & NDR_IN) {
26801                 if (r->in.handle == NULL) {
26802                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26803                 }
26804                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26808                 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));
26809                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26812                 if (r->in.status_code == NULL) {
26813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26814                 }
26815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26816         }
26817         if (flags & NDR_OUT) {
26818                 if (r->out.out_data == NULL) {
26819                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26820                 }
26821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26822                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26823                 if (r->out.needed == NULL) {
26824                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26825                 }
26826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26827                 if (r->out.status_code == NULL) {
26828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26829                 }
26830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26831                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26832         }
26833         return NDR_ERR_SUCCESS;
26834 }
26835
26836 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26837 {
26838         TALLOC_CTX *_mem_save_handle_0;
26839         TALLOC_CTX *_mem_save_needed_0;
26840         TALLOC_CTX *_mem_save_status_code_0;
26841         if (flags & NDR_IN) {
26842                 ZERO_STRUCT(r->out);
26843
26844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26845                         NDR_PULL_ALLOC(ndr, r->in.handle);
26846                 }
26847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26851                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26852                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26853                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26854                         return 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));
26855                 }
26856                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26857                 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));
26858                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26862                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26863                 }
26864                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26865                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26868                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26869                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26870                 NDR_PULL_ALLOC(ndr, r->out.needed);
26871                 ZERO_STRUCTP(r->out.needed);
26872                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26873                 *r->out.status_code = *r->in.status_code;
26874         }
26875         if (flags & NDR_OUT) {
26876                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26878                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26879                 }
26880                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26882                         NDR_PULL_ALLOC(ndr, r->out.needed);
26883                 }
26884                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26885                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26888                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26889                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26890                 }
26891                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26892                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26894                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26895                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26896                 if (r->out.out_data) {
26897                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26898                 }
26899         }
26900         return NDR_ERR_SUCCESS;
26901 }
26902
26903 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26904 {
26905         ndr_print_struct(ndr, name, "spoolss_XcvData");
26906         ndr->depth++;
26907         if (flags & NDR_SET_VALUES) {
26908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26909         }
26910         if (flags & NDR_IN) {
26911                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26912                 ndr->depth++;
26913                 ndr_print_ptr(ndr, "handle", r->in.handle);
26914                 ndr->depth++;
26915                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26916                 ndr->depth--;
26917                 ndr_print_string(ndr, "function_name", r->in.function_name);
26918                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26919                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26920                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26921                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26922                 ndr->depth++;
26923                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26924                 ndr->depth--;
26925                 ndr->depth--;
26926         }
26927         if (flags & NDR_OUT) {
26928                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26929                 ndr->depth++;
26930                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26931                 ndr->depth++;
26932                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26933                 ndr->depth--;
26934                 ndr_print_ptr(ndr, "needed", r->out.needed);
26935                 ndr->depth++;
26936                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26937                 ndr->depth--;
26938                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26939                 ndr->depth++;
26940                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26941                 ndr->depth--;
26942                 ndr_print_WERROR(ndr, "result", r->out.result);
26943                 ndr->depth--;
26944         }
26945         ndr->depth--;
26946 }
26947
26948 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26949 {
26950         if (flags & NDR_IN) {
26951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26952                 if (r->in.servername) {
26953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26956                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26957                 }
26958                 if (r->in.info_ctr == NULL) {
26959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26960                 }
26961                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26962                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26963         }
26964         if (flags & NDR_OUT) {
26965                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26966         }
26967         return NDR_ERR_SUCCESS;
26968 }
26969
26970 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26971 {
26972         uint32_t _ptr_servername;
26973         TALLOC_CTX *_mem_save_servername_0;
26974         TALLOC_CTX *_mem_save_info_ctr_0;
26975         if (flags & NDR_IN) {
26976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26977                 if (_ptr_servername) {
26978                         NDR_PULL_ALLOC(ndr, r->in.servername);
26979                 } else {
26980                         r->in.servername = NULL;
26981                 }
26982                 if (r->in.servername) {
26983                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26984                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26987                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26988                                 return 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));
26989                         }
26990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26991                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26993                 }
26994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26995                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26996                 }
26997                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26998                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26999                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27001                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27002         }
27003         if (flags & NDR_OUT) {
27004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27005         }
27006         return NDR_ERR_SUCCESS;
27007 }
27008
27009 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27010 {
27011         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27012         ndr->depth++;
27013         if (flags & NDR_SET_VALUES) {
27014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27015         }
27016         if (flags & NDR_IN) {
27017                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27018                 ndr->depth++;
27019                 ndr_print_ptr(ndr, "servername", r->in.servername);
27020                 ndr->depth++;
27021                 if (r->in.servername) {
27022                         ndr_print_string(ndr, "servername", r->in.servername);
27023                 }
27024                 ndr->depth--;
27025                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27026                 ndr->depth++;
27027                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27028                 ndr->depth--;
27029                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27030                 ndr->depth--;
27031         }
27032         if (flags & NDR_OUT) {
27033                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27034                 ndr->depth++;
27035                 ndr_print_WERROR(ndr, "result", r->out.result);
27036                 ndr->depth--;
27037         }
27038         ndr->depth--;
27039 }
27040
27041 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27042 {
27043         if (flags & NDR_IN) {
27044         }
27045         if (flags & NDR_OUT) {
27046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27047         }
27048         return NDR_ERR_SUCCESS;
27049 }
27050
27051 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27052 {
27053         if (flags & NDR_IN) {
27054         }
27055         if (flags & NDR_OUT) {
27056                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27057         }
27058         return NDR_ERR_SUCCESS;
27059 }
27060
27061 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27062 {
27063         ndr_print_struct(ndr, name, "spoolss_5a");
27064         ndr->depth++;
27065         if (flags & NDR_SET_VALUES) {
27066                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27067         }
27068         if (flags & NDR_IN) {
27069                 ndr_print_struct(ndr, "in", "spoolss_5a");
27070                 ndr->depth++;
27071                 ndr->depth--;
27072         }
27073         if (flags & NDR_OUT) {
27074                 ndr_print_struct(ndr, "out", "spoolss_5a");
27075                 ndr->depth++;
27076                 ndr_print_WERROR(ndr, "result", r->out.result);
27077                 ndr->depth--;
27078         }
27079         ndr->depth--;
27080 }
27081
27082 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27083 {
27084         if (flags & NDR_IN) {
27085         }
27086         if (flags & NDR_OUT) {
27087                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27088         }
27089         return NDR_ERR_SUCCESS;
27090 }
27091
27092 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27093 {
27094         if (flags & NDR_IN) {
27095         }
27096         if (flags & NDR_OUT) {
27097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27098         }
27099         return NDR_ERR_SUCCESS;
27100 }
27101
27102 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27103 {
27104         ndr_print_struct(ndr, name, "spoolss_5b");
27105         ndr->depth++;
27106         if (flags & NDR_SET_VALUES) {
27107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27108         }
27109         if (flags & NDR_IN) {
27110                 ndr_print_struct(ndr, "in", "spoolss_5b");
27111                 ndr->depth++;
27112                 ndr->depth--;
27113         }
27114         if (flags & NDR_OUT) {
27115                 ndr_print_struct(ndr, "out", "spoolss_5b");
27116                 ndr->depth++;
27117                 ndr_print_WERROR(ndr, "result", r->out.result);
27118                 ndr->depth--;
27119         }
27120         ndr->depth--;
27121 }
27122
27123 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27124 {
27125         if (flags & NDR_IN) {
27126         }
27127         if (flags & NDR_OUT) {
27128                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27129         }
27130         return NDR_ERR_SUCCESS;
27131 }
27132
27133 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27134 {
27135         if (flags & NDR_IN) {
27136         }
27137         if (flags & NDR_OUT) {
27138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27139         }
27140         return NDR_ERR_SUCCESS;
27141 }
27142
27143 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27144 {
27145         ndr_print_struct(ndr, name, "spoolss_5c");
27146         ndr->depth++;
27147         if (flags & NDR_SET_VALUES) {
27148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27149         }
27150         if (flags & NDR_IN) {
27151                 ndr_print_struct(ndr, "in", "spoolss_5c");
27152                 ndr->depth++;
27153                 ndr->depth--;
27154         }
27155         if (flags & NDR_OUT) {
27156                 ndr_print_struct(ndr, "out", "spoolss_5c");
27157                 ndr->depth++;
27158                 ndr_print_WERROR(ndr, "result", r->out.result);
27159                 ndr->depth--;
27160         }
27161         ndr->depth--;
27162 }
27163
27164 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27165 {
27166         if (flags & NDR_IN) {
27167         }
27168         if (flags & NDR_OUT) {
27169                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27170         }
27171         return NDR_ERR_SUCCESS;
27172 }
27173
27174 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27175 {
27176         if (flags & NDR_IN) {
27177         }
27178         if (flags & NDR_OUT) {
27179                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27180         }
27181         return NDR_ERR_SUCCESS;
27182 }
27183
27184 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27185 {
27186         ndr_print_struct(ndr, name, "spoolss_5d");
27187         ndr->depth++;
27188         if (flags & NDR_SET_VALUES) {
27189                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27190         }
27191         if (flags & NDR_IN) {
27192                 ndr_print_struct(ndr, "in", "spoolss_5d");
27193                 ndr->depth++;
27194                 ndr->depth--;
27195         }
27196         if (flags & NDR_OUT) {
27197                 ndr_print_struct(ndr, "out", "spoolss_5d");
27198                 ndr->depth++;
27199                 ndr_print_WERROR(ndr, "result", r->out.result);
27200                 ndr->depth--;
27201         }
27202         ndr->depth--;
27203 }
27204
27205 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27206 {
27207         if (flags & NDR_IN) {
27208         }
27209         if (flags & NDR_OUT) {
27210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27211         }
27212         return NDR_ERR_SUCCESS;
27213 }
27214
27215 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27216 {
27217         if (flags & NDR_IN) {
27218         }
27219         if (flags & NDR_OUT) {
27220                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27221         }
27222         return NDR_ERR_SUCCESS;
27223 }
27224
27225 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27226 {
27227         ndr_print_struct(ndr, name, "spoolss_5e");
27228         ndr->depth++;
27229         if (flags & NDR_SET_VALUES) {
27230                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27231         }
27232         if (flags & NDR_IN) {
27233                 ndr_print_struct(ndr, "in", "spoolss_5e");
27234                 ndr->depth++;
27235                 ndr->depth--;
27236         }
27237         if (flags & NDR_OUT) {
27238                 ndr_print_struct(ndr, "out", "spoolss_5e");
27239                 ndr->depth++;
27240                 ndr_print_WERROR(ndr, "result", r->out.result);
27241                 ndr->depth--;
27242         }
27243         ndr->depth--;
27244 }
27245
27246 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27247 {
27248         if (flags & NDR_IN) {
27249         }
27250         if (flags & NDR_OUT) {
27251                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27252         }
27253         return NDR_ERR_SUCCESS;
27254 }
27255
27256 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27257 {
27258         if (flags & NDR_IN) {
27259         }
27260         if (flags & NDR_OUT) {
27261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27262         }
27263         return NDR_ERR_SUCCESS;
27264 }
27265
27266 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27267 {
27268         ndr_print_struct(ndr, name, "spoolss_5f");
27269         ndr->depth++;
27270         if (flags & NDR_SET_VALUES) {
27271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27272         }
27273         if (flags & NDR_IN) {
27274                 ndr_print_struct(ndr, "in", "spoolss_5f");
27275                 ndr->depth++;
27276                 ndr->depth--;
27277         }
27278         if (flags & NDR_OUT) {
27279                 ndr_print_struct(ndr, "out", "spoolss_5f");
27280                 ndr->depth++;
27281                 ndr_print_WERROR(ndr, "result", r->out.result);
27282                 ndr->depth--;
27283         }
27284         ndr->depth--;
27285 }
27286
27287 static const struct ndr_interface_call spoolss_calls[] = {
27288         {
27289                 "spoolss_EnumPrinters",
27290                 sizeof(struct spoolss_EnumPrinters),
27291                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27292                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27293                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27294                 false,
27295         },
27296         {
27297                 "spoolss_OpenPrinter",
27298                 sizeof(struct spoolss_OpenPrinter),
27299                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27300                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27301                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27302                 false,
27303         },
27304         {
27305                 "spoolss_SetJob",
27306                 sizeof(struct spoolss_SetJob),
27307                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27308                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27309                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27310                 false,
27311         },
27312         {
27313                 "spoolss_GetJob",
27314                 sizeof(struct spoolss_GetJob),
27315                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27316                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27317                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27318                 false,
27319         },
27320         {
27321                 "spoolss_EnumJobs",
27322                 sizeof(struct spoolss_EnumJobs),
27323                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27324                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27325                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27326                 false,
27327         },
27328         {
27329                 "spoolss_AddPrinter",
27330                 sizeof(struct spoolss_AddPrinter),
27331                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27332                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27333                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27334                 false,
27335         },
27336         {
27337                 "spoolss_DeletePrinter",
27338                 sizeof(struct spoolss_DeletePrinter),
27339                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27340                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27341                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27342                 false,
27343         },
27344         {
27345                 "spoolss_SetPrinter",
27346                 sizeof(struct spoolss_SetPrinter),
27347                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27348                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27349                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27350                 false,
27351         },
27352         {
27353                 "spoolss_GetPrinter",
27354                 sizeof(struct spoolss_GetPrinter),
27355                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27356                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27357                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27358                 false,
27359         },
27360         {
27361                 "spoolss_AddPrinterDriver",
27362                 sizeof(struct spoolss_AddPrinterDriver),
27363                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27364                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27365                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27366                 false,
27367         },
27368         {
27369                 "spoolss_EnumPrinterDrivers",
27370                 sizeof(struct spoolss_EnumPrinterDrivers),
27371                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27372                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27373                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27374                 false,
27375         },
27376         {
27377                 "spoolss_GetPrinterDriver",
27378                 sizeof(struct spoolss_GetPrinterDriver),
27379                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27380                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27381                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27382                 false,
27383         },
27384         {
27385                 "spoolss_GetPrinterDriverDirectory",
27386                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27387                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27388                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27389                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27390                 false,
27391         },
27392         {
27393                 "spoolss_DeletePrinterDriver",
27394                 sizeof(struct spoolss_DeletePrinterDriver),
27395                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27396                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27397                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27398                 false,
27399         },
27400         {
27401                 "spoolss_AddPrintProcessor",
27402                 sizeof(struct spoolss_AddPrintProcessor),
27403                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27404                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27405                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27406                 false,
27407         },
27408         {
27409                 "spoolss_EnumPrintProcessors",
27410                 sizeof(struct spoolss_EnumPrintProcessors),
27411                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27412                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27413                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27414                 false,
27415         },
27416         {
27417                 "spoolss_GetPrintProcessorDirectory",
27418                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27419                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27420                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27421                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27422                 false,
27423         },
27424         {
27425                 "spoolss_StartDocPrinter",
27426                 sizeof(struct spoolss_StartDocPrinter),
27427                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27428                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27429                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27430                 false,
27431         },
27432         {
27433                 "spoolss_StartPagePrinter",
27434                 sizeof(struct spoolss_StartPagePrinter),
27435                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27436                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27437                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27438                 false,
27439         },
27440         {
27441                 "spoolss_WritePrinter",
27442                 sizeof(struct spoolss_WritePrinter),
27443                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27444                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27445                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27446                 false,
27447         },
27448         {
27449                 "spoolss_EndPagePrinter",
27450                 sizeof(struct spoolss_EndPagePrinter),
27451                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27452                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27453                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27454                 false,
27455         },
27456         {
27457                 "spoolss_AbortPrinter",
27458                 sizeof(struct spoolss_AbortPrinter),
27459                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27460                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27461                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27462                 false,
27463         },
27464         {
27465                 "spoolss_ReadPrinter",
27466                 sizeof(struct spoolss_ReadPrinter),
27467                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27468                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27469                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27470                 false,
27471         },
27472         {
27473                 "spoolss_EndDocPrinter",
27474                 sizeof(struct spoolss_EndDocPrinter),
27475                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27476                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27477                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27478                 false,
27479         },
27480         {
27481                 "spoolss_AddJob",
27482                 sizeof(struct spoolss_AddJob),
27483                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27484                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27485                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27486                 false,
27487         },
27488         {
27489                 "spoolss_ScheduleJob",
27490                 sizeof(struct spoolss_ScheduleJob),
27491                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27492                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27493                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27494                 false,
27495         },
27496         {
27497                 "spoolss_GetPrinterData",
27498                 sizeof(struct spoolss_GetPrinterData),
27499                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27500                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27501                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27502                 false,
27503         },
27504         {
27505                 "spoolss_SetPrinterData",
27506                 sizeof(struct spoolss_SetPrinterData),
27507                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27508                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27509                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27510                 false,
27511         },
27512         {
27513                 "spoolss_WaitForPrinterChange",
27514                 sizeof(struct spoolss_WaitForPrinterChange),
27515                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27516                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27517                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27518                 false,
27519         },
27520         {
27521                 "spoolss_ClosePrinter",
27522                 sizeof(struct spoolss_ClosePrinter),
27523                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27524                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27525                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27526                 false,
27527         },
27528         {
27529                 "spoolss_AddForm",
27530                 sizeof(struct spoolss_AddForm),
27531                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27532                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27533                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27534                 false,
27535         },
27536         {
27537                 "spoolss_DeleteForm",
27538                 sizeof(struct spoolss_DeleteForm),
27539                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27540                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27541                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27542                 false,
27543         },
27544         {
27545                 "spoolss_GetForm",
27546                 sizeof(struct spoolss_GetForm),
27547                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27548                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27549                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27550                 false,
27551         },
27552         {
27553                 "spoolss_SetForm",
27554                 sizeof(struct spoolss_SetForm),
27555                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27556                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27557                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27558                 false,
27559         },
27560         {
27561                 "spoolss_EnumForms",
27562                 sizeof(struct spoolss_EnumForms),
27563                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27564                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27565                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27566                 false,
27567         },
27568         {
27569                 "spoolss_EnumPorts",
27570                 sizeof(struct spoolss_EnumPorts),
27571                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27572                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27573                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27574                 false,
27575         },
27576         {
27577                 "spoolss_EnumMonitors",
27578                 sizeof(struct spoolss_EnumMonitors),
27579                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27580                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27581                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27582                 false,
27583         },
27584         {
27585                 "spoolss_AddPort",
27586                 sizeof(struct spoolss_AddPort),
27587                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27588                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27589                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27590                 false,
27591         },
27592         {
27593                 "spoolss_ConfigurePort",
27594                 sizeof(struct spoolss_ConfigurePort),
27595                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27596                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27597                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27598                 false,
27599         },
27600         {
27601                 "spoolss_DeletePort",
27602                 sizeof(struct spoolss_DeletePort),
27603                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27604                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27605                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27606                 false,
27607         },
27608         {
27609                 "spoolss_CreatePrinterIC",
27610                 sizeof(struct spoolss_CreatePrinterIC),
27611                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27612                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27613                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27614                 false,
27615         },
27616         {
27617                 "spoolss_PlayGDIScriptOnPrinterIC",
27618                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27619                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27620                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27621                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27622                 false,
27623         },
27624         {
27625                 "spoolss_DeletePrinterIC",
27626                 sizeof(struct spoolss_DeletePrinterIC),
27627                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27628                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27629                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27630                 false,
27631         },
27632         {
27633                 "spoolss_AddPrinterConnection",
27634                 sizeof(struct spoolss_AddPrinterConnection),
27635                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27636                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27637                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27638                 false,
27639         },
27640         {
27641                 "spoolss_DeletePrinterConnection",
27642                 sizeof(struct spoolss_DeletePrinterConnection),
27643                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27644                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27645                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27646                 false,
27647         },
27648         {
27649                 "spoolss_PrinterMessageBox",
27650                 sizeof(struct spoolss_PrinterMessageBox),
27651                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27652                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27653                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27654                 false,
27655         },
27656         {
27657                 "spoolss_AddMonitor",
27658                 sizeof(struct spoolss_AddMonitor),
27659                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27660                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27661                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27662                 false,
27663         },
27664         {
27665                 "spoolss_DeleteMonitor",
27666                 sizeof(struct spoolss_DeleteMonitor),
27667                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27668                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27669                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27670                 false,
27671         },
27672         {
27673                 "spoolss_DeletePrintProcessor",
27674                 sizeof(struct spoolss_DeletePrintProcessor),
27675                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27676                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27677                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27678                 false,
27679         },
27680         {
27681                 "spoolss_AddPrintProvidor",
27682                 sizeof(struct spoolss_AddPrintProvidor),
27683                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27684                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27685                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27686                 false,
27687         },
27688         {
27689                 "spoolss_DeletePrintProvidor",
27690                 sizeof(struct spoolss_DeletePrintProvidor),
27691                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27692                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27693                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27694                 false,
27695         },
27696         {
27697                 "spoolss_EnumPrintProcDataTypes",
27698                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27699                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27700                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27701                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27702                 false,
27703         },
27704         {
27705                 "spoolss_ResetPrinter",
27706                 sizeof(struct spoolss_ResetPrinter),
27707                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27708                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27709                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27710                 false,
27711         },
27712         {
27713                 "spoolss_GetPrinterDriver2",
27714                 sizeof(struct spoolss_GetPrinterDriver2),
27715                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27716                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27717                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27718                 false,
27719         },
27720         {
27721                 "spoolss_FindFirstPrinterChangeNotification",
27722                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27723                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27724                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27725                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27726                 false,
27727         },
27728         {
27729                 "spoolss_FindNextPrinterChangeNotification",
27730                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27731                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27732                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27733                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27734                 false,
27735         },
27736         {
27737                 "spoolss_FindClosePrinterNotify",
27738                 sizeof(struct spoolss_FindClosePrinterNotify),
27739                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27740                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27741                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27742                 false,
27743         },
27744         {
27745                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27746                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27747                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27748                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27749                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27750                 false,
27751         },
27752         {
27753                 "spoolss_ReplyOpenPrinter",
27754                 sizeof(struct spoolss_ReplyOpenPrinter),
27755                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27756                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27757                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27758                 false,
27759         },
27760         {
27761                 "spoolss_RouterReplyPrinter",
27762                 sizeof(struct spoolss_RouterReplyPrinter),
27763                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27764                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27765                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27766                 false,
27767         },
27768         {
27769                 "spoolss_ReplyClosePrinter",
27770                 sizeof(struct spoolss_ReplyClosePrinter),
27771                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27772                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27773                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27774                 false,
27775         },
27776         {
27777                 "spoolss_AddPortEx",
27778                 sizeof(struct spoolss_AddPortEx),
27779                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27780                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27781                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27782                 false,
27783         },
27784         {
27785                 "spoolss_RouterFindFirstPrinterChangeNotification",
27786                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27787                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27788                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27789                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27790                 false,
27791         },
27792         {
27793                 "spoolss_SpoolerInit",
27794                 sizeof(struct spoolss_SpoolerInit),
27795                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27796                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27797                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27798                 false,
27799         },
27800         {
27801                 "spoolss_ResetPrinterEx",
27802                 sizeof(struct spoolss_ResetPrinterEx),
27803                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27804                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27805                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27806                 false,
27807         },
27808         {
27809                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27810                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27811                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27812                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27813                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27814                 false,
27815         },
27816         {
27817                 "spoolss_RouterReplyPrinterEx",
27818                 sizeof(struct spoolss_RouterReplyPrinterEx),
27819                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27820                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27821                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27822                 false,
27823         },
27824         {
27825                 "spoolss_RouterRefreshPrinterChangeNotify",
27826                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27827                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27828                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27829                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27830                 false,
27831         },
27832         {
27833                 "spoolss_44",
27834                 sizeof(struct spoolss_44),
27835                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27836                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27837                 (ndr_print_function_t) ndr_print_spoolss_44,
27838                 false,
27839         },
27840         {
27841                 "spoolss_OpenPrinterEx",
27842                 sizeof(struct spoolss_OpenPrinterEx),
27843                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27844                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27845                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27846                 false,
27847         },
27848         {
27849                 "spoolss_AddPrinterEx",
27850                 sizeof(struct spoolss_AddPrinterEx),
27851                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27852                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27853                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27854                 false,
27855         },
27856         {
27857                 "spoolss_47",
27858                 sizeof(struct spoolss_47),
27859                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27860                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27861                 (ndr_print_function_t) ndr_print_spoolss_47,
27862                 false,
27863         },
27864         {
27865                 "spoolss_EnumPrinterData",
27866                 sizeof(struct spoolss_EnumPrinterData),
27867                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27868                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27869                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27870                 false,
27871         },
27872         {
27873                 "spoolss_DeletePrinterData",
27874                 sizeof(struct spoolss_DeletePrinterData),
27875                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27876                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27877                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27878                 false,
27879         },
27880         {
27881                 "spoolss_4a",
27882                 sizeof(struct spoolss_4a),
27883                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27884                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27885                 (ndr_print_function_t) ndr_print_spoolss_4a,
27886                 false,
27887         },
27888         {
27889                 "spoolss_4b",
27890                 sizeof(struct spoolss_4b),
27891                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27892                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27893                 (ndr_print_function_t) ndr_print_spoolss_4b,
27894                 false,
27895         },
27896         {
27897                 "spoolss_4c",
27898                 sizeof(struct spoolss_4c),
27899                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27900                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27901                 (ndr_print_function_t) ndr_print_spoolss_4c,
27902                 false,
27903         },
27904         {
27905                 "spoolss_SetPrinterDataEx",
27906                 sizeof(struct spoolss_SetPrinterDataEx),
27907                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27908                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27909                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27910                 false,
27911         },
27912         {
27913                 "spoolss_GetPrinterDataEx",
27914                 sizeof(struct spoolss_GetPrinterDataEx),
27915                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27916                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27917                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27918                 false,
27919         },
27920         {
27921                 "spoolss_EnumPrinterDataEx",
27922                 sizeof(struct spoolss_EnumPrinterDataEx),
27923                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27924                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27925                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27926                 false,
27927         },
27928         {
27929                 "spoolss_EnumPrinterKey",
27930                 sizeof(struct spoolss_EnumPrinterKey),
27931                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27932                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27933                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27934                 false,
27935         },
27936         {
27937                 "spoolss_DeletePrinterDataEx",
27938                 sizeof(struct spoolss_DeletePrinterDataEx),
27939                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27940                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27941                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27942                 false,
27943         },
27944         {
27945                 "spoolss_DeletePrinterKey",
27946                 sizeof(struct spoolss_DeletePrinterKey),
27947                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27948                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27949                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27950                 false,
27951         },
27952         {
27953                 "spoolss_53",
27954                 sizeof(struct spoolss_53),
27955                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27956                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27957                 (ndr_print_function_t) ndr_print_spoolss_53,
27958                 false,
27959         },
27960         {
27961                 "spoolss_DeletePrinterDriverEx",
27962                 sizeof(struct spoolss_DeletePrinterDriverEx),
27963                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27964                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27965                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27966                 false,
27967         },
27968         {
27969                 "spoolss_55",
27970                 sizeof(struct spoolss_55),
27971                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27972                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27973                 (ndr_print_function_t) ndr_print_spoolss_55,
27974                 false,
27975         },
27976         {
27977                 "spoolss_56",
27978                 sizeof(struct spoolss_56),
27979                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27980                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27981                 (ndr_print_function_t) ndr_print_spoolss_56,
27982                 false,
27983         },
27984         {
27985                 "spoolss_57",
27986                 sizeof(struct spoolss_57),
27987                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27988                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27989                 (ndr_print_function_t) ndr_print_spoolss_57,
27990                 false,
27991         },
27992         {
27993                 "spoolss_XcvData",
27994                 sizeof(struct spoolss_XcvData),
27995                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27996                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27997                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27998                 false,
27999         },
28000         {
28001                 "spoolss_AddPrinterDriverEx",
28002                 sizeof(struct spoolss_AddPrinterDriverEx),
28003                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28004                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28005                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28006                 false,
28007         },
28008         {
28009                 "spoolss_5a",
28010                 sizeof(struct spoolss_5a),
28011                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28012                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28013                 (ndr_print_function_t) ndr_print_spoolss_5a,
28014                 false,
28015         },
28016         {
28017                 "spoolss_5b",
28018                 sizeof(struct spoolss_5b),
28019                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28020                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28021                 (ndr_print_function_t) ndr_print_spoolss_5b,
28022                 false,
28023         },
28024         {
28025                 "spoolss_5c",
28026                 sizeof(struct spoolss_5c),
28027                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28028                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28029                 (ndr_print_function_t) ndr_print_spoolss_5c,
28030                 false,
28031         },
28032         {
28033                 "spoolss_5d",
28034                 sizeof(struct spoolss_5d),
28035                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28036                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28037                 (ndr_print_function_t) ndr_print_spoolss_5d,
28038                 false,
28039         },
28040         {
28041                 "spoolss_5e",
28042                 sizeof(struct spoolss_5e),
28043                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28044                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28045                 (ndr_print_function_t) ndr_print_spoolss_5e,
28046                 false,
28047         },
28048         {
28049                 "spoolss_5f",
28050                 sizeof(struct spoolss_5f),
28051                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28052                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28053                 (ndr_print_function_t) ndr_print_spoolss_5f,
28054                 false,
28055         },
28056         { NULL, 0, NULL, NULL, NULL, false }
28057 };
28058
28059 static const char * const spoolss_endpoint_strings[] = {
28060         "ncacn_np:[\\pipe\\spoolss]",
28061 };
28062
28063 static const struct ndr_interface_string_array spoolss_endpoints = {
28064         .count  = 1,
28065         .names  = spoolss_endpoint_strings
28066 };
28067
28068 static const char * const spoolss_authservice_strings[] = {
28069         "host",
28070 };
28071
28072 static const struct ndr_interface_string_array spoolss_authservices = {
28073         .count  = 1,
28074         .names  = spoolss_authservice_strings
28075 };
28076
28077
28078 const struct ndr_interface_table ndr_table_spoolss = {
28079         .name           = "spoolss",
28080         .syntax_id      = {
28081                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28082                 NDR_SPOOLSS_VERSION
28083         },
28084         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28085         .num_calls      = 96,
28086         .calls          = spoolss_calls,
28087         .endpoints      = &spoolss_endpoints,
28088         .authservices   = &spoolss_authservices
28089 };
28090